সরাসরি পর্বে যান
পর্ব ৫৯ · ৮২-এর মধ্যে · মডিউল ১০

Mutation testing — test-এর test, mutmut আর mutation score

Mutation Testing — Testing Your Tests, mutmut and the Mutation Score

Taught in Bangla, this lesson tests the tests: it inserts one small fault at a time and checks whether the suite notices. An in-page engine built on Python's ast shows four suites with the same 100% coverage but very different kill counts. A real cosmic-ray run on the demo shop's pricing module leaves 11 of 74 mutants alive despite full line and branch coverage, and eight targeted boundary tests bring it to 74 of 74. mutmut's refusal to run natively on Windows is shown as is, not faked.

এই পর্বে যা শিখবেন

  • Mutant, mutation operator (ROR, AOR, সংখ্যা বদল, শর্ত উল্টানো, statement মোছা) আর first-order বনাম higher-order mutant
  • Killed, survived, timeout আর equivalent mutant চেনা, আর mutation score হিসাব করা
  • Python-এর ast দিয়ে নিজের ছোট mutation engine চালিয়ে দেখা, আর ১০০% coverage-এর suite কেন দুর্বল হতে পারে তা প্রমাণ করা
  • cosmic-ray দিয়ে নিজের কম্পিউটারে সত্যিকারের run, survivor রিপোর্ট পড়া আর সীমার মানের test দিয়ে survivor মারা
  • Equivalent mutant, খরচ, diff-ভিত্তিক mutation আর কোন প্রকল্পে কতটা mutation testing যুক্তিসঙ্গত, তা বিচার করা

১ · Test-এর test — ইচ্ছা করে ভুল বসিয়ে দেখা

ব্যাংকে জাল নোট ধরার মেশিন কেনা হলো। মেশিনটি কাজ করে কি না, কীভাবে নিশ্চিত হবেন? একশোটি আসল নোট ঢুকিয়ে সবুজ বাতি দেখলে কিছুই প্রমাণ হয় না, কারণ একটি নষ্ট মেশিনও সব নোটে সবুজ বাতি দিতে পারে। আসল পরীক্ষা হলো জানা কয়েকটি জাল নোট ঢোকানো: জলছাপ নেই এমন একটি, নিরাপত্তা সুতা নেই এমন একটি, রং একটু আলাদা এমন একটি। মেশিন যেগুলো ধরতে পারল না, সেখানেই তার দুর্বলতা।

আপনার test suite সেই মেশিন। সবুজ test দেখে আমরা ভাবি কোড ঠিক আছে, কিন্তু একটি দুর্বল suite ভুল কোডেও সবুজ থাকে। পর্ব ১৩ (White-box testing)-এর শেষে আপনি দেখেছেন: বাজারঘরের coupon-এর কোডে >-এর জায়গায় >= বসালেও ১০০% branch coverage-এর আটটি test সবুজ ছিল, ধরেছিল শুধু সীমার মান 1000-এর test. সেখানে ভুলটি আমরা হাতে একবার বসিয়েছিলাম। Mutation testing সেই কাজটিকেই নিয়মমাফিক আর স্বয়ংক্রিয় করে: একটি tool কোডের প্রতিটি সম্ভাব্য জায়গায় নিয়ম মেনে ছোট ভুল বসায়, প্রতিটি ভুলের জন্য আলাদা করে suite চালায়, আর হিসাব দেয় কতগুলো ভুল ধরা পড়ল।

Mutant = আসল কোড + একটিমাত্র ছোট বদল
কোনো test লাল → killed (ভালো) · সব test সবুজ → survived (test-এ ফাঁক)

খেয়াল করুন, এখানে উদ্দেশ্য কোডের bug খোঁজা নয়; উদ্দেশ্য test-এর দুর্বলতা খোঁজা। আসল কোড ঠিক আছে ধরে নিয়েই কাজ শুরু হয়, আর প্রতিটি mutant একটি “সম্ভাব্য bug”-এর নমুনা। পর্ব ১৩-এর seeded defect একটি ছিল, হাতে বাছা; এখানে tool শত শত তৈরি করে, এমন জায়গায়ও যেখানে মানুষ ভাবেননি। সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৫০-এ mutation testing-এর প্রথম পরিচয় হয়েছে; এখানে পুরো কাজের ধারা, হিসাব, সত্যিকারের tool আর সিদ্ধান্তের কৌশল।

দুটি ভিত্তি-অনুমান

Mutation testing শুধু ছোট বদল বানায়: একটি চিহ্ন, একটি সংখ্যা, একটি শর্ত। বাস্তব bug তো অনেক সময় বড় আর জটিল। তাহলে ছোট mutant ধরতে পারা কেন অর্থবহ? দুটি অনুমান এর উত্তর দেয়:

  • Competent programmer hypothesis: অভিজ্ঞ প্রোগ্রামার মোটামুটি সঠিক কোড লেখেন; তাঁর ভুল সাধারণত সঠিক প্রোগ্রাম থেকে অল্প দূরে, যেমন > আর >= গুলিয়ে ফেলা, ভুল সংখ্যা, উল্টো শর্ত। তাই ছোট বদল বাস্তব ভুলের ভালো নমুনা।
  • Coupling effect: যে test-এর দল সব সরল ভুল ধরে, সে অনেক জটিল ভুলও ধরে, কারণ জটিল ভুল প্রায়ই কয়েকটি সরল ভুলের যোগফল। (নামটি কোডের module-এর coupling থেকে আলাদা ধারণা।)

দুটিই অনুমান, প্রমাণিত সত্য নয়। পরে গবেষণায় এদের পক্ষে বেশ কিছু প্রমাণ পাওয়া গেছে, আবার সীমাও দেখা গেছে: requirement-এ থাকা কিন্তু কোডে না-লেখা আচরণ কোনো mutant দিয়ে ধরা যায় না, কারণ যে লাইন নেই, তা বদলানোও যায় না। ভাবনার প্রশ্ন ০২-এ এ নিয়ে আরও আছে।

ধারণাটির উৎস হিসেবে সাধারণত Richard Lipton-এর ১৯৭০-এর দশকের শুরুর একটি ছাত্র-প্রবন্ধের কথা বলা হয়। ব্যাপক পরিচিতি আসে Richard DeMillo, Richard Lipton আর Frederick Sayward-এর ১৯৭৮ সালের প্রবন্ধ “Hints on Test Data Selection: Help for the Practicing Programmer” (IEEE Computer) থেকে, যেখানে competent programmer আর coupling effect-এর যুক্তি দেওয়া হয়। প্রায় একই সময়ে Richard Hamlet (১৯৭৭) স্বাধীনভাবে কাছাকাছি ধারণা প্রকাশ করেন। ১৯৮০-এর দশকে Fortran-এর জন্য Mothra নামের একটি বড় mutation system গবেষণায় ব্যবহৃত হয়। খুঁটিনাটি তারিখ নিয়ে বিভিন্ন উৎসে সামান্য পার্থক্য আছে।

২ · Mutant আর mutation operator — কোন ভুল, কোথায়

Tool এলোমেলো ভুল বসায় না; বসায় নির্দিষ্ট নিয়মে। প্রতিটি নিয়মকে বলে mutation operator: “প্রতিটি >-কে >= করো”, “প্রতিটি সংখ্যায় ১ যোগ করো” ধরনের। একটি operator কোডের যত জায়গায় খাটে, তত mutant তৈরি হয়। প্রচলিত operator-গুলোর নাম গবেষণার সাহিত্যে সংক্ষেপে লেখা হয়; বাজারঘরের কোডে উদাহরণসহ:

Operatorবদলবাজারঘরে উদাহরণকোন বাস্তব ভুলের নমুনা
ROR (relational operator replacement)তুলনার চিহ্ন বদলsubtotal > 1000 → >= 1000সীমায় এক ঘর ভুল (off-by-one)
AOR (arithmetic operator replacement)গাণিতিক চিহ্ন বদল* 10 // 100 → * 10 / 100ভুল সূত্র, পূর্ণ টাকার বদলে দশমিক
সংখ্যা বদল (constant replacement)সংখ্যায় ±১ বা ০COUPON_CAP = 300 → 301ভুল সীমা বা ভুল হার লেখা
LCR / শর্ত উল্টানোand ↔ or, not যোগif plus: → if not plus:শর্ত উল্টো, যুক্তির ভুল
Statement মোছাএকটি লাইন বাদstock কমানোর লাইন মুছে ফেলাভুলে যাওয়া ধাপ
Return বা মান বদলফেরত মান বদলreturn 0 → return 1ভুল ডিফল্ট

প্রতিটি mutant-এ ঠিক একটি বদল থাকলে তাকে বলে first-order mutant; প্রায় সব tool এটিই বানায়। একসাথে দুই বা বেশি বদল থাকলে higher-order mutant: সংখ্যায় বিস্ফোরিত হয়, আর coupling effect বলে বেশিরভাগ ক্ষেত্রে দরকারও নেই। তবে গবেষণায় দেখা গেছে কিছু higher-order mutant এমন সূক্ষ্ম ভুলের নমুনা দেয় যা আলাদা আলাদা first-order mutant দেয় না; এটি এখনো গবেষণার বিষয়।

এবার একটি mutant-এর পুরো জীবন ধাপে ধাপে দেখুন। কোড বাজারঘরের coupon নিয়মের ছোট রূপ, আর তিনটি test আছে যেগুলো দেখতে যথেষ্ট মনে হয়: বড় অর্ডার, ছোট অর্ডার, সর্বোচ্চ ছাড়। “পরে” চাপুন:

1def coupon_discount(subtotal):2    if subtotal > 1000:3        return min(subtotal * 10 // 100, 300)4    return 0
Mutant M01 · ROR
লাইন ২ এখন
চলছে
ফল · expected
অবস্থা
  1. Baseline. আগে আসল কোডে পুরো suite চালানো হয়: test_big (১৫০০ → ১৫০), test_small (৫০০ → ০), test_cap (৫০০০ → ৩০০), তিনটিই সবুজ। আসল কোডেই কোনো test লাল থাকলে mutation-এর ফল অর্থহীন, তাই সব tool প্রথমে এটি যাচাই করে।
  2. জন্ম। ROR operator লাইন ২-এর > খুঁজে পেয়ে তাকে >= বানাল। এটি mutant M01: আসল কোড থেকে ঠিক একটি চিহ্নের দূরত্ব, অর্থাৎ first-order. বাকি কোড অপরিবর্তিত।
  3. প্রথম test. test_big ১৫০০ পাঠায়। ১৫০০ দুই চিহ্নেই ১০০০-এর বেশি, তাই লাইন ৩ চলে আর ফল ১৫০, expected-ও ১৫০. সবুজ।
  4. বেঁচে গেল। test_small-এ ৫০০ দুই চিহ্নেই শর্ত মিথ্যা, ফল ০; test_cap-এ ৫০০০, ফল ৩০০. তিনটি test-ই সবুজ, তাই M01 survived. কোনো test-এর input ঠিক ১০০০-এ বসেনি, অথচ > আর >= শুধু সেখানেই আলাদা।
  5. Survivor থেকে প্রশ্ন। কোন input আসল আর mutant-কে আলাদা করে? শুধু ১০০০: আসল কোড দেয় ০, mutant দেয় ১০০. নিয়ম বলে “১০০০ টাকার বেশি হলে ছাড়”, তাই expected ০. এটি পর্ব ০৮ (Boundary value analysis)-এর on point, যা এই suite-এ ছিল না।
  6. মৃত্যু। নতুন test_1000 mutant-এ চালালে ফল ১০০, expected ০: লাল, তাই M01 killed. আসল কোডে একই test সবুজ। একটি survivor একটি নির্দিষ্ট, নামসহ test-এর ফাঁক দেখাল, আর তা পূরণ হলো।

এই ছোট গল্পে mutation testing-এর পুরো দর্শন আছে। Survivor কোনো সংখ্যা নয়; এটি একটি প্রশ্ন: “এই ভুলটি কেউ করলে আপনার কোন test তা ধরবে?” উত্তর “কোনোটিই না” হলে দুটি পথ: নতুন test লেখা, অথবা প্রমাণ করা যে ভুলটি আসলে ভুলই নয় (§৭-এর equivalent mutant).

৩ · Killed, survived, timeout, equivalent — আর mutation score

প্রতিটি mutant-এর ওপর suite চালানোর পর tool তাকে একটি শ্রেণিতে রাখে। নাম tool ভেদে একটু আলাদা, কিন্তু ধারণা একই:

Killed

Killed mutant: অন্তত একটি test fail করেছে বা error দিয়েছে। Suite ভুলটি ধরেছে। এটিই কাঙ্ক্ষিত ফল।

Survived

Survived mutant: সব test সবুজ। হয় একটি test নেই বা দুর্বল, নয়তো mutant-টি equivalent. প্রতিটিই বিচার করার মতো।

Timeout

Timeout: mutant-এ suite নির্দিষ্ট সময়ের মধ্যে শেষ হয়নি, যেমন loop-এর i += 1 বদলে i -= 1 হয়ে অসীম loop. বেশিরভাগ tool একে killed হিসেবে গোনে।

Equivalent

Equivalent mutant: লেখা আলাদা, আচরণ কোনো input-এই আলাদা নয়। কোনো test একে মারতে পারে না; হিসাব থেকে বাদ দেওয়া হয়।

এর বাইরে কিছু tool আরও একটি অবস্থা দেখায়: mutant-টি চালানোই গেল না, যেমন import-এর সময় ভাঙল বা syntax ভুল হলো। cosmic-ray একে বলে “incompetent”, PIT-এ “non-viable”. এগুলো test-এর শক্তি সম্পর্কে কিছু বলে না, তাই আলাদা রাখা হয়। আরেকটি সূক্ষ্মতা: suite-এ কোনো flaky test (পর্ব ৪০, Flaky test) থাকলে mutant ভুল করে killed দেখাতে পারে, কারণ test-টি কোড বদলের জন্য নয়, এমনিতেই লাল হয়েছে। তাই mutation-এর আগে suite স্থির করা জরুরি।

Mutation score = killed ÷ (মোট mutant − equivalent) × ১০০
timeout সাধারণত killed-এর দলে · চালানো যায়নি এমন mutant হিসাবের বাইরে

Mutation score-এর হর থেকে equivalent mutant বাদ যায়, কারণ যাকে মারা অসম্ভব তার জন্য suite-কে দোষ দেওয়া ঠিক নয়। বাস্তবে কোনগুলো equivalent তা প্রায়ই জানা থাকে না, তাই অনেক tool সরাসরি killed ÷ মোট দেখায়; তখন সংখ্যাটি প্রকৃত score-এর চেয়ে একটু কম। নিচের ছবিতে পুরো প্রক্রিয়া, চারটি mutant-এর চার রকম পরিণতি দিয়ে:

Mutation testing-এর কাজের ধারা

Original code → operators → mutants → run the suite on each → classify → score

আসল কোড থেকে mutant, প্রতিটিতে test, চার রকম ফল আর mutation score আসল কোড + পুরো test suite baseline: সব test সবুজ Mutation operator ROR · AOR · সংখ্যা · not M1 > → >= M2 * → + M3 += → -= M4 <= → < Survived test দুর্বল Killed test লাল Timeout killed গোনা Equivalent হিসাবের বাইরে Score = killed ÷ (মোট − equivalent) এখানে (১ + ১) ÷ (৪ − ১) = ৬৬.৭%
ছবি ৫৯.১ — M3-এর loop কখনো শেষ হয় না, তাই সময়সীমা পেরিয়ে থামানো হয় আর killed ধরা হয়। M4 হলো §৭-এর cart-এর উদাহরণ: পরিমাণ ০ হলে লাইনটি বাদ দেওয়া আর ০ যোগ করা একই ফল দেয়।

৪ · নিজের হাতে একটি ছোট mutation engine

Tool-এর ভেতরে কী ঘটে, তা বোঝার সবচেয়ে ভালো উপায় নিজে একটি বানানো। Python-এর ast module কোডকে একটি গাছে (abstract syntax tree) রূপ দেয়: প্রতিটি তুলনা, প্রতিটি গাণিতিক চিহ্ন, প্রতিটি সংখ্যা সেখানে আলাদা একটি node. নিচের প্রোগ্রাম চারটি কাজ করে:

  1. coupon-এর কোড থেকে গাছ বানিয়ে প্রতিটি node ঘুরে দেখে (ast.walk).
  2. তুলনা হলে ROR (> থেকে >= বা <), গাণিতিক চিহ্ন হলে AOR (* থেকে +, // থেকে /), সংখ্যা হলে ±১, প্রতিবার একটি করে বদল।
  3. বদলানো গাছ থেকে নতুন কোড লিখে (ast.unparse) চালিয়ে একটি নতুন function পায়।
  4. প্রতিটি mutant-এ দুটি suite চালায় unittest দিয়ে: Weak (ওপরের তিনটি test, যারা ১০০% line আর branch coverage দেয়) আর Strong (একই তিনটি + সীমার তিনটি)।

“চালান” চাপুন; প্রথমবার ব্রাউজারে Pyodide (ব্রাউজারের ভেতরের Python) নামতে কয়েক সেকেন্ড লাগে।

import ast, io, unittest
SRC = """def coupon_discount(subtotal):
    if subtotal > 1000:
        return min(subtotal * 10 // 100, 300)
    return 0"""
SWAP = {ast.Gt: [ast.GtE, ast.Lt], ast.Mult: [ast.Add], ast.FloorDiv: [ast.Div]}
def mutants():                    # yields (changed line, mutated source)
    for i, probe in enumerate(ast.walk(ast.parse(SRC))):
        if isinstance(probe, ast.Compare): choices = SWAP[type(probe.ops[0])]
        elif isinstance(probe, ast.BinOp): choices = SWAP[type(probe.op)]
        elif isinstance(probe, ast.Constant): choices = [+1, -1]
        else: continue
        for c in choices:
            tree = ast.parse(SRC); node = list(ast.walk(tree))[i]
            if isinstance(c, int): node.value += c
            elif isinstance(node, ast.Compare): node.ops = [c()]
            else: node.op = c()
            yield ast.unparse(tree).splitlines()[node.lineno - 1].strip(), ast.unparse(tree)
class Weak(unittest.TestCase):        # 100% line and branch coverage
    def test_big(self):   self.assertEqual(f(1500), 150)
    def test_small(self): self.assertEqual(f(500), 0)
    def test_cap(self):   self.assertEqual(f(5000), 300)
class Strong(Weak):                   # + boundary tests (BVA)
    def test_1000(self):  self.assertEqual(f(1000), 0)
    def test_1001(self):  self.assertEqual(f(1001), 100)
    def test_floor(self): self.assertEqual(f(1009), 100)
killed = {"Weak": 0, "Strong": 0}
for n, (line, src) in enumerate(mutants(), 1):
    ns = {}; exec(src, ns); f = ns["coupon_discount"]; row = []
    for cls in (Weak, Strong):
        r = unittest.TextTestRunner(stream=io.StringIO()).run(unittest.defaultTestLoader.loadTestsFromTestCase(cls))
        killed[cls.__name__] += not r.wasSuccessful(); row.append("killed" if not r.wasSuccessful() else "SURVIVED")
    print(f"M{n:02} {line:40} {row[0]:8} {row[1]}")
print({k: f"{v}/{n} = {100 * v / n:.1f}%" for k, v in killed.items()})

আসল আউটপুট (ব্রাউজারের Python):

M01 if subtotal >= 1000:                     SURVIVED killed
M02 if subtotal < 1000:                      killed   killed
M03 return 1                                 killed   killed
M04 return -1                                killed   killed
M05 if subtotal > 1001:                      SURVIVED killed
M06 if subtotal > 999:                       SURVIVED killed
M07 return min(subtotal * 10 / 100, 300)     SURVIVED killed
M08 return min(subtotal * 10 // 100, 301)    killed   killed
M09 return min(subtotal * 10 // 100, 299)    killed   killed
M10 return min((subtotal + 10) // 100, 300)  killed   killed
M11 return min(subtotal * 10 // 101, 300)    killed   killed
M12 return min(subtotal * 10 // 99, 300)     killed   killed
M13 return min(subtotal * 11 // 100, 300)    killed   killed
M14 return min(subtotal * 9 // 100, 300)     killed   killed
{'Weak': '10/14 = 71.4%', 'Strong': '14/14 = 100.0%'}

১৪টি mutant: দুটি ROR, দুটি AOR আর পাঁচটি সংখ্যার প্রতিটিতে +১ ও −১ মিলে দশটি। M03 আর M04 এসেছে শেষ লাইনের return 0-এর ০ থেকে। গাছ ঘোরার ক্রমে তা আগে পড়ে, তাই নম্বর আগে।

Weak suite ১০/১৪ = ৭১.৪%. চারটি survivor-এর তিনটি (M01, M05, M06) সীমা নড়ানো: >=, ১০০১ আর ৯৯৯. তিনটি test-এর কোনোটি ৯৯৯ থেকে ১০০১-এর মধ্যে বসেনি, তাই সীমা এক ঘর সরলেও কেউ টের পায় না। চতুর্থ survivor M07 মজার: // বদলে / হলে ১৫০০-এ ফল ১৫০.০, আর Python-এ 150.0 == 150 সত্য। ৫০০০-এ min(500.0, 300) ফেরত দেয় ৩০০. অর্থাৎ যেসব input বেছেছেন সেখানে পূর্ণ টাকা আর দশমিকের পার্থক্য দেখা যায় না; ১০০৯-এর মতো একটি “অগোল” মান লাগে (আসল ১০০, mutant ১০০.৯)।

Strong suite ১৪/১৪. নতুন তিনটি test হলো সীমার দুই পাশ (১০০০ আর ১০০১) আর পূর্ণ টাকার নিয়ম (১০০৯ → ১০০)। খেয়াল করুন, তিনটির expected মানই এসেছে নিয়ম থেকে: “বেশি হলে”, “পূর্ণ টাকায়”। আসল tool আরও অনেক operator চালায়, ফাইলে লিখে আলাদা process-এ test চালায়, সময়সীমা রাখে; কিন্তু মূল loop ঠিক এটাই।

৫ · Coverage কেন মিথ্যা বলে — চারটি suite, একই ১০০%

Coverage আর mutation score দুটি আলাদা প্রশ্নের উত্তর দেয়। Statement coverage জিজ্ঞাসা করে: “এই লাইন কি কোনো test-এ চলেছে?” Mutation score জিজ্ঞাসা করে: “এই লাইনে ভুল হলে কোনো test কি লাল হতো?” প্রথমটির জন্য test-কে শুধু কোড চালাতে হয়; দ্বিতীয়টির জন্য ফল যাচাই করতে হয়। পর্ব ২২ (ভালো unit test-এর গঠন)-এ যে assertion-এর মান নিয়ে কথা হয়েছিল, mutation score তাকেই সংখ্যায় মাপে।

নিচের প্রোগ্রাম বাজারঘরের delivery_charge-এর ওপর চারটি suite চালায়। চারটিই একই চারটি input ব্যবহার করে, তাই coverage একই। পার্থক্য শুধু test oracle-এ, অর্থাৎ ফল ঠিক কি না কীভাবে বিচার হচ্ছে:

  • a_calls_only: শুধু function ডাকে, কিছুই assert করে না।
  • b_weak_assert: শুধু দেখে ফল ০, ৬০ বা ১২০-এর একটি কি না (“বৈধ একটি charge”).
  • c_exact: প্রতিটি input-এর হুবহু expected মান।
  • d_exact_bva: c_exact + সীমার দুটি মান, ঢাকায় ১৯৯৯ আর ২০০০.

Line coverage মাপা হয় sys.settrace দিয়ে, পর্ব ১৩-এর ছোট coverage tool-এর মতো; mutant বানানো হয় প্রতিটি তুলনা উল্টে আর প্রতিটি সংখ্যায় ১ যোগ করে।

import ast, sys
SRC = """def delivery_charge(district, subtotal, plus=False):
    if district == "Dhaka":
        if subtotal >= 2000:
            return 0
        return 60
    if plus:
        return 60
    return 120"""
FLIP = {ast.Eq: ast.NotEq, ast.GtE: ast.Gt}
def build(src): ns = {}; exec(src, ns); return ns["delivery_charge"]
def mutants():                 # flip each comparison, add 1 to each number
    for i, probe in enumerate(ast.walk(ast.parse(SRC))):
        if isinstance(probe, ast.Compare) or type(getattr(probe, "value", "")) in (int, bool):
            tree = ast.parse(SRC); node = list(ast.walk(tree))[i]
            if isinstance(node, ast.Compare): node.ops = [FLIP[type(node.ops[0])]()]
            else: node.value += 1
            yield ast.unparse(tree).splitlines()[node.lineno - 1].strip(), build(ast.unparse(tree))
CASES = [("Dhaka", 2500, False, 0), ("Dhaka", 1500, False, 60),
         ("Sylhet", 500, True, 60), ("Rajshahi", 500, False, 120)]
BVA = [("Dhaka", 1999, False, 60), ("Dhaka", 2000, False, 0)]
def a_calls_only(f):  [f(d, s, p) for d, s, p, e in CASES]
def b_weak_assert(f): assert all(f(d, s, p) in (0, 60, 120) for d, s, p, e in CASES)
def c_exact(f):       assert all(f(d, s, p) == e for d, s, p, e in CASES)
def d_exact_bva(f):   assert all(f(d, s, p) == e for d, s, p, e in CASES + BVA)
MS = list(mutants())
for suite in (a_calls_only, b_weak_assert, c_exact, d_exact_bva):
    hit, f, alive = set(), build(SRC), []
    tracer = lambda fr, ev, a: (fr.f_code is f.__code__ and ev == "line" and hit.add(fr.f_lineno)) or tracer
    sys.settrace(tracer); suite(f); sys.settrace(None)
    for label, m in MS:
        try: suite(m); alive.append(label)
        except AssertionError: pass
    print(f"{suite.__name__:13} lines {len(hit)}/7  killed {len(MS) - len(alive)}/{len(MS)}")
print("survivors of d_exact_bva:", alive)

আসল আউটপুট:

a_calls_only  lines 7/7  killed 0/8
b_weak_assert lines 7/7  killed 4/8
c_exact       lines 7/7  killed 5/8
d_exact_bva   lines 7/7  killed 7/8
survivors of d_exact_bva: ['def delivery_charge(district, subtotal, plus=1):']

চার suite-এরই line coverage ৭/৭ = ১০০%, অথচ mutation score ০% থেকে ৮৭.৫%. Coverage রিপোর্ট এই চারটিকে আলাদা করতে পারে না। নিচের stepper-এ প্রতিটি ধাপ, আর শেষ survivor-টি কেন বাঁচল।

delivery_charge · ৭টি লাইন · ৮টি mutant
suite
যাচাই
line coverage
killed
বাকি survivor
  1. শুধু ডাকা। চারটি input সব লাইন চালায়, তাই coverage ১০০%. কিন্তু কোনো assert নেই, তাই mutant যা-ই ফেরত দিক, test সবুজ: ০/৮ killed. এই suite আর “কোনো test নেই” একই শক্তির, শুধু রিপোর্টে সুন্দর দেখায়।
  2. দুর্বল assert. “ফল একটি বৈধ charge” যাচাই করে ১, ৬১ বা ১২১ ফেরত দেওয়া চারটি সংখ্যার mutant মরে: ৪/৮ = ৫০%. কিন্তু == থেকে != বাঁচে: ঢাকার অর্ডার বাইরের হিসাবে গিয়ে ১২০ পায়, যা এখনো “বৈধ” মান।
  3. হুবহু মান। এবার != মরে (ঢাকা ২৫০০-এ ০-এর বদলে ১২০)। বাকি তিনটি: সীমার দুটি (> আর ২০০১), কারণ ঢাকার test ১৫০০ আর ২৫০০, সীমা থেকে দূরে; আর plus=1. স্কোর ৫/৮ = ৬২.৫%.
  4. সীমার মান। ঢাকায় ২০০০ (expected ০) দুটি সীমার mutant-ই মারে: >-এ আর ২০০১-এ ২০০০ আর ফ্রি থাকে না। ১৯৯৯-এর test সীমার অন্য পাশ পাহারা দেয়। স্কোর ৭/৮ = ৮৭.৫%, শুধু plus=1 বাকি।
  5. Default-এর ফাঁক। চারটি suite-ই প্রতিবার plus নিজে পাঠিয়েছে, তাই default argument plus=False কখনো ব্যবহার হয়নি। কেউ ভুলে default বদলালে plus না পাঠানো প্রতিটি caller বাইরের জেলায় ১২০-এর বদলে ৬০ দিত। delivery_charge("Rajshahi", 500) == 120 যোগ করলে ৮/৮; scratch script-এ মিলিয়ে দেখা। Coverage এখানেও ১০০% ছিল।
মূল শিক্ষা

Coverage প্রয়োজনীয় শর্ত, যথেষ্ট নয়: যে লাইন চলেনি তার ভুল কোনো test ধরতে পারে না, কিন্তু চললেই ধরবে এমন নয়। Mutation score তাই coverage-এর পরের প্রশ্ন। সাধারণত coverage আগে মাপুন (সস্তা), তারপর গুরুত্বপূর্ণ module-এ mutation (দামি)।

৬ · ডেস্কটপে সত্যিকারের run — mutmut, cosmic-ray আর survivor রিপোর্ট

এবার আসল tool, আসল প্রকল্প। নিচের সবকিছু এই কোর্সের লেখার সময় একটি সাধারণ Windows ডেস্কটপে সত্যিকারভাবে চালানো: Python 3.12.13, pytest 9.2.0 (MIT লাইসেন্স), coverage.py 7.17.3 (Apache 2.0), uv দিয়ে বানানো একটি ছোট প্রকল্পে; path নিরপেক্ষ করা। কোড বাজারঘরের shared app-এর rules.py থেকে নেওয়া coupon আর delivery-র নিয়ম, seeded bug-এর switch বাদ দিয়ে।

প্রথম চেষ্টা: mutmut

Python-এ সবচেয়ে পরিচিত mutation tool সম্ভবত mutmut (BSD 3-Clause লাইসেন্স)। ব্যবহার সহজ: pyproject.toml-এ কোন ফোল্ডার mutate হবে লিখে mutmut run, তারপর mutmut results বা টার্মিনালের ভেতরের UI mutmut browse. কিন্তু Windows-এ সত্যিকারের run-এর ফল ছিল এই:

$ uv add mutmut
$ uv run mutmut run
To run mutmut on Windows, please use the WSL. Native windows support is tracked in issue https://github.com/boxed/mutmut/issues/397

অর্থাৎ mutmut 3.8.1 সরাসরি Windows-এ চলে না; Linux, macOS বা Windows-এর WSL (Windows Subsystem for Linux) লাগে। এই কম্পিউটারে WSL-এর কোনো Linux distribution ছিল না, তাই mutmut-এর run এখানে চালানো হয়নি; তার কোনো আউটপুট এই পাতায় নেই। Linux বা WSL-এ কাজের ধারা একই, শুধু command আলাদা; খুঁটিনাটি mutmut-এর docs-এ মিলিয়ে নিন। এই অভিজ্ঞতাও শিক্ষণীয়: কোনো tool বাছার আগে আপনার দলের সব operating system-এ চলে কি না দেখুন।

দ্বিতীয় চেষ্টা: cosmic-ray

cosmic-ray 8.9.0 (MIT লাইসেন্স) Windows-এ চলে। এটি একটি session ফাইলে (SQLite) প্রতিটি mutant-এর কাজ আর ফল রাখে, তাই মাঝপথে থামলে আবার চালিয়ে শেষ করা যায়। এই tool কোনো usage তথ্য পাঠায় বলে জানা নেই; তবু সব run-এ DO_NOT_TRACK=1 রাখা ছিল।

cd ~/bazarghar-qa
uv init --vcs none --author-from none
uv add pytest coverage cosmic-ray
"""Bazarghar pricing rules (course copy of rules.py)."""

COUPON_THRESHOLD = 1000   # strictly MORE than this qualifies
COUPON_CAP = 300


def coupon_discount(subtotal):
    """10% off when the product total is MORE than 1000, floored, max 300."""
    if subtotal < 0:
        raise ValueError("subtotal must not be negative")
    if subtotal > COUPON_THRESHOLD:
        return min(subtotal * 10 // 100, COUPON_CAP)
    return 0


def delivery_charge(district, subtotal, plus=False):
    """Dhaka 60, free from 2000 (before coupon); outside 120, Plus 60."""
    if district == "Dhaka":
        if subtotal >= 2000:
            return 0
        return 60
    if plus:
        return 60
    return 120

প্রথম suite আটটি test-এর, প্রতিটি একটি করে assert: coupon ১৫০০ → ১৫০, ৫০০ → ০, ৫০০০ → ৩০০, −১ → ValueError; delivery ঢাকা ২৫০০ → ০, ঢাকা ১৫০০ → ৬০, সিলেট ৫০০ Plus → ৬০, রাজশাহী ৫০০ → ১২০. দেখতে যুক্তিসঙ্গত, আর coverage নিখুঁত:

$ uv run coverage run --branch --source=src -m pytest -q
........                                            [100%]
8 passed in 0.03s
$ uv run coverage report -m
Name             Stmts   Miss Branch BrPart  Cover   Missing
------------------------------------------------------------
src\pricing.py      16      0     10      0   100%
------------------------------------------------------------
TOTAL               16      0     10      0   100%

cosmic-ray-এর config একটি ছোট TOML ফাইল: কোন ফাইল mutate হবে, প্রতিটি mutant-এ কোন command test চালাবে, আর সময়সীমা।

[cosmic-ray]
module-path = "src/pricing.py"
timeout = 10.0
excluded-modules = []
test-command = "pytest -x -q -p no:cacheprovider tests"

[cosmic-ray.distributor]
name = "local"

-x প্রথম লাল test-এ থামায়: mutant মারতে একটিই যথেষ্ট, তাই সময় বাঁচে। Windows-এ প্রথমে python -m pytest লেখা হয়েছিল; cosmic-ray-এর চালানো subprocess তখন প্রকল্পের নয়, অন্য একটি Python খুঁজে পেয়ে No module named pytest দিচ্ছিল, আর সব mutant “incompetent” হচ্ছিল। প্রকল্পের নিজের pytest command সরাসরি লিখে সমস্যা মিটেছে। এমন ক্ষেত্রে baseline সবসময় আগে যাচাই করুন:

$ uv run cosmic-ray baseline cr.toml
$ uv run cosmic-ray init cr.toml session.sqlite
$ uv run cosmic-ray exec cr.toml session.sqlite
$ uv run cr-report session.sqlite --surviving-only --show-diff
…
[job-id] 8df1e9159b83409a88f342c50808d3c9
src\pricing.py core/ReplaceComparisonOperator_Gt_GtE 0
worker outcome: WorkerOutcome.NORMAL, test outcome: TestOutcome.SURVIVED
=== DIFF ===
--- mutation diff ---
--- a/src\pricing.py
+++ b/src\pricing.py
@@ -8,7 +8,7 @@
     """10% off when the product total is MORE than 1000, floored, max 300."""
     if subtotal < 0:
         raise ValueError("subtotal must not be negative")
-    if subtotal > COUPON_THRESHOLD:
+    if subtotal >= COUPON_THRESHOLD:
         return min(subtotal * 10 // 100, COUPON_CAP)
     return 0
…
total jobs: 74
complete: 74 (100.00%)
surviving mutants: 11 (14.86%)

Baseline কিছু না লিখে শেষ হওয়া মানে আসল কোডে suite সবুজ। init ৭৪টি mutant-এর তালিকা বানায়: তুলনার চিহ্ন বদল ২৪টি (চারটি তুলনা × ছয় বিকল্প), গাণিতিক চিহ্ন বদল ২২টি (* আর //-এর প্রতিটির ১১ বিকল্প), সংখ্যা বদল ২২টি (১১টি সংখ্যা × ±১), if-এর শর্তে not যোগ ৫টি, আর plus=False-কে True করা ১টি। exec একটি একটি করে ফাইল বদলে test চালায় আর শেষে ফাইল আগের অবস্থায় ফেরায়; ৭৪টিতে লেগেছে প্রায় ২০ সেকেন্ড, যদিও suite নিজে চলে ০.০৩ সেকেন্ডে। পার্থক্যটা প্রতিবার নতুন process আর pytest চালু হওয়ার খরচ, §৭-এ ফিরব।

ফল: ৬৩টি killed, ১১টি survived; mutation score ৬৩ ÷ ৭৪ = ৮৫.১%, coverage ১০০%. রিপোর্টের প্রতিটি survivor-এ লাইন নম্বর, operator-এর নাম আর diff থাকে; ওপরে দেখানো এন্ট্রিটি পরিচিত >=. এগারোটি survivor-কে দলে ভাগ করে পড়া সবচেয়ে কাজের। লাইন নম্বরগুলো ওপরের pricing.py-এর:

cosmic-ray · pricing.py · ৭৪টি mutant
দল
mutant
কেন বাঁচল
যে test মারে
score
  1. সারসংক্ষেপ। ৭৪টির মধ্যে ১১টি বাঁচল, অথচ coverage ১০০%. এগারোটিকে আলাদা আলাদা না দেখে কারণ ধরে দল বানান; দেখা যায় দল মাত্র ছয়টি, আর প্রতিটি দলের জন্য এক বা দুটি test যথেষ্ট।
  2. Coupon-এর সীমা। >=, ১০০১ আর ৯৯৯: তিনটিই সীমাকে এক ঘর নড়ায়। ১০০০ (expected ০) মারে >= আর ৯৯৯-কে, ১০০১ (expected ১০০) মারে ১০০১-কে। পর্ব ০৮-এর দুই-মান BVA: on point আর off point.
  3. Delivery-র সীমা। একই গল্প ঢাকার ফ্রি delivery-তে: >, ২০০১ আর ১৯৯৯. ঢাকা ২০০০ (expected ০) প্রথম দুটি মারে, ঢাকা ১৯৯৯ (expected ৬০) শেষটি।
  4. শূন্য। < 0 থেকে <= 0 বা < 1 হলে ০ টাকার subtotal-এ ValueError ওঠে। খালি cart-এর ছাড় ০, error নয়; কিন্তু কোনো test ০ পাঠায়নি। coupon_discount(0) == 0 দুটিকেই মারে। শূন্য প্রায় সবসময় একটি আলাদা সীমা।
  5. পূর্ণ টাকা। // থেকে /: §৪-এর M07-এর মতো, ১৫০০-এ ১৫০.০ আর 150.0 == 150 সত্য। ১০০৯ (expected ১০০, mutant ১০০.৯) ধরে। নিয়মের “পূর্ণ টাকায়” অংশটি আগে কোনো test যাচাই করেনি, এখন floor division-এর ফল পাহারায় আছে।
  6. জেলার নাম। district == "Dhaka" থেকে <= "Dhaka": লেখার তুলনায় বর্ণক্রমে D-এর আগের যেকোনো জেলা “ঢাকা” হয়ে যায়। Test-এর রাজশাহী আর সিলেট বর্ণক্রমে পরে, তাই কিছু বদলায়নি। Chattogram ৫০০ (expected ১২০, mutant ৬০) ধরে। এই সাতটি test যোগ করে আবার run: ৭৩/৭৪ = ৯৮.৬%.
  7. শেষ survivor. == থেকে is: test-এ লেখা "Dhaka" আর কোডের "Dhaka" CPython-এ সাধারণত একই object (string interning), তাই is-ও সত্য। কিন্তু form বা JSON থেকে আসা নাম runtime-এ তৈরি নতুন object. "".join(["Dha", "ka"]) দিয়ে বানানো নামে ২৫০০ টাকার test (expected ০) mutant-এ ১২০ পায়। অষ্টম test-এর পরে ৭৪/৭৪, coverage তখনও সেই ১০০%.

শেষ দুটি run-এর সত্যিকারের সারাংশ (প্রথমটি সাতটি নতুন test-এর পরে, দ্বিতীয়টি অষ্টম test-এর পরে):

$ uv run pytest -q -p no:cacheprovider
...............                                     [100%]
15 passed in 0.02s
$ uv run cr-report session2.sqlite
…
total jobs: 74
complete: 74 (100.00%)
surviving mutants: 1 (1.35%)

$ uv run pytest -q -p no:cacheprovider
................                                    [100%]
16 passed in 0.02s
$ uv run cr-report session3.sqlite
…
total jobs: 74
complete: 74 (100.00%)
surviving mutants: 0 (0.00%)
$ uv run coverage report -m
Name             Stmts   Miss Branch BrPart  Cover   Missing
------------------------------------------------------------
src\pricing.py      16      0     10      0   100%

প্রতিটি নতুন session-এর জন্য আগে init আর exec চালানো হয়েছে; পাতায় আঁটাতে সেগুলো আর আউটপুটের কিছু ফাঁকা জায়গা ছাঁটা। coverage-এর সংখ্যা আটটি test-এ যা ছিল, ষোলোটিতেও হুবহু তাই: Stmts ১৬, Branch ১০, Cover ১০০%. নতুন আটটি test-এর কোনোটি coverage রিপোর্টে একটুও পার্থক্য আনেনি, অথচ প্রতিটি অন্তত একটি বাস্তব ভুল ধরার ক্ষমতা যোগ করেছে।

is নিয়ে সতর্কতা: Python 3.8 থেকে literal-এর সাথে is লিখলে (district is "Dhaka") Python একটি SyntaxWarning দেয়, কারণ এটি প্রায় সবসময় ভুল। Mutation tool এমন mutant ইচ্ছা করেই বানায়, কারণ মানুষও এই ভুল করেন। এটিকে equivalent ভেবে বাদ দিলে আসল একটি bug-এর শ্রেণি অদেখা থেকে যেত: test-এ লেখা মান আর বাস্তবে আসা মান সবসময় একই object নয়।

অন্য ভাষার tool

  • PIT (pitest), Java-র জন্য, Apache 2.0 লাইসেন্স: Maven বা Gradle plugin, bytecode-এ mutant বানায়, আর শুধু সেই mutant-এর লাইন ছোঁয়া test চালায় বলে বেশ দ্রুত। Java প্রোগ্রামিং কোর্সের পর্ব ৪৭-এ নাম এসেছে।
  • Stryker, JavaScript/TypeScript-এর জন্য (StrykerJS; C#-এর জন্য Stryker.NET আর Scala-র জন্য Stryker4s আলাদা প্রকল্প), Apache 2.0: Vitest বা Jest-এর সাথে চলে, HTML রিপোর্টে প্রতিটি mutant দেখায়। ফুল-স্ট্যাক ওয়েব ফ্রেমওয়ার্ক কোর্সের পর্ব ৭৩-এ উল্লেখ আছে।
  • mutmut আর cosmic-ray, Python: ওপরে দেখলেন। দুটিই নির্দিষ্ট লাইন বা operator বাদ দেওয়ার উপায় রাখে, যেমন cosmic-ray-এর filter tool আর mutmut-এর কোডের ভেতরে লেখা মন্তব্য; নাম আর রূপ docs-এ মিলিয়ে নিন।

৭ · Equivalent mutant, খরচ আর বড় পরিসরে mutation

Mutation testing-এর দুটি পুরোনো সমস্যা: কিছু survivor আসলে ভুলই নয়, আর পুরো প্রক্রিয়া দামি। দুটিই বাস্তব, আর দুটিরই ব্যবহারিক সমাধান আছে।

Equivalent mutant — যাকে মারা অসম্ভব

বাজারঘরের cart-এ পরিমাণ ০ বা কম হলে লাইনটি বাদ যায় (if qty <= 0: continue). Mutant বানাল qty < 0. এখন পরিমাণ ০-এর লাইন বাদ যায় না, যোগ হয়: দাম × ০ = ০. মোট একই। কোনো test একে মারতে পারবে না, কারণ বাইরে থেকে দেখা আচরণে কোনো পার্থক্য নেই। নিচের প্রোগ্রাম ছোট একটি input-জগতে প্রতিটি সম্ভাব্য cart চেষ্টা করে দেখে, আর তুলনার জন্য coupon-এর >= mutant আর is mutant-ও যাচাই করে:

import random
from itertools import product
def cart_total(items):
    total = 0
    for price, qty in items:
        if qty <= 0:
            continue
        total += price * qty
    return total

def cart_total_mutant(items):         # mutant: <= became <
    total = 0
    for price, qty in items:
        if qty < 0:
            continue
        total += price * qty
    return total

lines = list(product([0, 50, 120], range(-2, 4)))          # (price, qty)
carts = [[]] + [[a] for a in lines] + [[a, b] for a in lines for b in lines]
diff = [c for c in carts if cart_total(c) != cart_total_mutant(c)]
print(f"cart  <= vs < : {len(carts)} carts tried, {len(diff)} give a different total")

coupon = lambda s: min(s * 10 // 100, 300) if s > 1000 else 0
coupon_mutant = lambda s: min(s * 10 // 100, 300) if s >= 1000 else 0
diff = [s for s in range(0, 5001) if coupon(s) != coupon_mutant(s)]
print(f"coupon > vs >=: {len(diff)} of 5001 subtotals differ: {diff}")
random.seed(59)
runs = sum(1000 in [random.randint(0, 5000) for _ in range(100)] for _ in range(1000))
print(f"100 random subtotals per run: 1000 was picked in {runs} of 1000 runs")

DHAKA = "Dhaka"
is_dhaka_mutant = lambda d: d is DHAKA                     # mutant: == became is
typed = "".join(["Dha", "ka"])                             # e.g. from a form
print("literal:", is_dhaka_mutant("Dhaka"), "| typed:", is_dhaka_mutant(typed), "| ==:", typed == DHAKA)

আসল আউটপুট:

cart  <= vs < : 343 carts tried, 0 give a different total
coupon > vs >=: 1 of 5001 subtotals differ: [1000]
100 random subtotals per run: 1000 was picked in 20 of 1000 runs
literal: True | typed: False | ==: True

Cart: ৩৪৩টি cart (খালি, এক লাইনের ১৮টি, দুই লাইনের ৩২৪টি), একটিতেও পার্থক্য নেই। এটি একটি ছোট জগতে খোঁজা, প্রমাণ নয়; প্রমাণ আসে যুক্তি থেকে: দাম × ০ সবসময় ০. তাই এটি equivalent, হিসাব থেকে বাদ দিন। Coupon: ৫০০১টি subtotal-এর মধ্যে ঠিক একটিতে পার্থক্য, ১০০০. এটি equivalent নয়, কিন্তু “প্রায় অদৃশ্য”: প্রতি run-এ ১০০টি এলোমেলো subtotal নিলে ১০০০-টি পড়েছে ১০০০টি run-এর মাত্র ২০টিতে, মোটামুটি হিসাবের ১ − (৫০০০/৫০০১)১০০ ≈ ২%-এর কাছাকাছি। এলোমেলো test সীমা প্রায় ধরে না; সীমা খুঁজতে নকশা লাগে। is: literal-এ সত্য, runtime-এ বানানো লেখায় মিথ্যা, যদিও == সত্য। দেখতে equivalent, আসলে নয়।

কোনো mutant equivalent কি না, তা সাধারণভাবে স্বয়ংক্রিয়ভাবে নির্ধারণ করা অসম্ভব: দুটি প্রোগ্রাম সব input-এ একই আচরণ করে কি না, সেই প্রশ্ন গণনাতত্ত্বে অসমাধানযোগ্য সমস্যার শ্রেণিতে পড়ে। তাই বাস্তবে তিনটি কৌশল চলে: (১) সস্তা স্বয়ংক্রিয় ছাঁকনি, যেমন compile করার পর mutant-এর machine code আসল কোডের সাথে হুবহু মিলে গেলে বাদ; (২) যেসব জায়গায় equivalent mutant প্রায়ই জন্মায় সেখানে operator বন্ধ রাখা, যেমন log বার্তার লেখা; (৩) বাকি survivor-এ মানুষের বিচার, আর একবার বিচার হলে চিহ্ন দিয়ে রাখা যাতে পরের run-এ আবার না আসে।

খরচ — কেন সব জায়গায় নয়

মোটা দাগে খরচ = mutant-এর সংখ্যা × প্রতিটিতে suite-এর সময়। Mutant-এর সংখ্যা কোডের আকারের সাথে বাড়ে: বাজারঘরের ২৪ লাইনের ফাইলেই ৭৪টি। হাজার লাইনের module আর পাঁচ মিনিটের suite হলে হিসাব দিন ছাড়িয়ে যায়। খরচ কমানোর প্রচলিত উপায়:

কৌশলকী করেঝুঁকি
শুধু ছোঁয়া test চালানোMutant-এর লাইন যে test চালায় না, সে mutant মারতে পারে না; coverage-এর তথ্য দিয়ে বাকি test বাদপ্রায় নেই; PIT এভাবে চলে
প্রথম লাল-এ থামাpytest -x-এর মতো; একটি লাল যথেষ্টকোন কোন test মারল জানা যায় না
Selective mutationঅল্প কয়েকটি operator, যারা বেশিরভাগ ফল দেয়কিছু ধরনের ফাঁক অদেখা থাকে
নমুনা নেওয়াসব mutant-এর বদলে এলোমেলো একটি ভাগscore আনুমানিক, নির্দিষ্ট survivor হারায়
Diff-ভিত্তিক mutationশুধু এই পরিবর্তনে বদলানো লাইনে mutantপুরোনো কোডের ফাঁক থেকে যায়
সমান্তরাল আর রাতেঅনেক worker-এ ভাগ করে, রাতের job-এফল দেরিতে আসে, কম্পিউটারের খরচ

বড় পরিসরের সবচেয়ে পরিচিত বিবরণ Google-এর। Goran Petrović আর Marko Ivanković-এর একটি প্রবন্ধ (ICSE-SEIP ২০১৮) আর পরে সহকর্মীদের সাথে একটি journal প্রবন্ধে (IEEE TSE, ২০২১ সালের দিকে) বর্ণিত পদ্ধতি সংক্ষেপে এমন: পুরো codebase-এ score নয়; code review-এর সময় শুধু বদলানো লাইনে, প্রতি লাইনে অল্প কয়েকটি mutant; log বা সহজ getter-এর মতো যে কোডে survivor সাধারণত অর্থহীন (তাঁদের ভাষায় “arid”), সেখানে mutant না বানানো; আর survivor-কে review-এর মন্তব্য হিসেবে দেখানো, যাতে developer সিদ্ধান্ত নেন। প্রবন্ধগুলো জানায়, developer-রা বেশিরভাগ survivor-কে কাজের মনে করেছেন; সংখ্যার খুঁটিনাটি মূল প্রবন্ধে দেখুন।

৮ · Survivor থেকে ভালো test — কাজের ধারা আর কোথায় ব্যবহার

Survivor হাতে পেলে প্রথম প্রলোভন: “এই mutant মরে এমন কিছু একটা assert লিখে দিই।” এভাবে score বাড়ে, কিন্তু test-এর মান না-ও বাড়তে পারে। ভালো অভ্যাস হলো প্রতিটি survivor-কে requirement-এর আয়নায় দেখা।

কাজের ধারা — প্রতিটি survivor-এর জন্য পাঁচ প্রশ্ন

  1. এটি কোন requirement-এর কোন আচরণ? >= survivor মানে “১০০০ টাকার বেশি”-র “বেশি” শব্দটি কেউ যাচাই করেনি।
  2. কোন input আসল আর mutant-কে আলাদা করে? সীমার mutant-এ সীমার মান, সংখ্যার mutant-এ এমন মান যেখানে সংখ্যাটির প্রভাব দেখা যায়, AOR-এ “অগোল” মান।
  3. সেই input-এ expected কী, requirement অনুযায়ী? কোড পড়ে নয়। আসল কোড ভুল হলে এখানেই ধরা পড়বে।
  4. Equivalent কি? কোনো input-এ পার্থক্য না পেলে যুক্তি দিয়ে প্রমাণ করুন, তারপর চিহ্ন দিন। সন্দেহ থাকলে সহকর্মীকে দেখান; §৬-এর is-এর মতো “দেখতে equivalent” mutant আছে।
  5. কোড কি সরল করা উচিত? কখনো survivor দেখায় যে একটি শর্ত বা লাইন অপ্রয়োজনীয়: মুছে ফেললেও কিছু বদলায় না। তখন test নয়, কোড বদলানোই উত্তর (developer-এর সাথে কথা বলে)।

কোথায় কতটা

পরিস্থিতিযুক্তিসঙ্গত ব্যবহার
টাকা, ছাড়, কর, stock-এর হিসাব (বাজারঘরের pricing, refund)পুরো module-এ নিয়মিত; survivor-এর তালিকা review-এ
অনুমতি আর নিরাপত্তার শর্তশর্ত উল্টানো আর তুলনার operator-এ বিশেষ নজর
প্রতিদিনের PRশুধু বদলানো লাইনে, অল্প কয়েকটি survivor মন্তব্যে
UI-এর চেহারা, log, configurationসাধারণত দরকার নেই; equivalent আর অর্থহীন survivor বেশি
AI বা নতুন সহকর্মীর লেখা test যাচাইছোট module-এ একবার চালিয়ে দেখা test আসলে কিছু ধরে কি না

CI-তে কোথায় বসাবেন, সেই নকশা পর্ব ৬৪ (CI-তে test pipeline)-এ, আর কোন metric অর্থবহ তা পর্ব ৬৭-এ। এখানে শুধু নীতি: mutation score-কে merge আটকানোর কড়া দরজা না বানিয়ে প্রবণতা আর আলোচনার উপকরণ রাখুন, কারণ equivalent mutant আর সময়ের চাপে সংখ্যাটি সহজে বিকৃত হয়। পর্ব ৫৮ (Property-based testing)-এর property-ভিত্তিক test-ও mutant মারার শক্তিশালী উপায়: একটি ভালো property হাজারো input-এ ফল যাচাই করে, যদিও §৭ দেখাল এলোমেলো input সীমায় প্রায় পড়ে না, তাই সীমার উদাহরণ আলাদা করে রাখা ভালো।

আরও গভীরে: René Just ও সহকর্মীদের ২০১৪ সালের FSE প্রবন্ধ (“Are Mutants a Valid Substitute for Real Faults in Software Testing?”) বাস্তব Java প্রকল্পের সত্যিকারের bug নিয়ে দেখায়, mutant ধরার ক্ষমতা আর বাস্তব bug ধরার ক্ষমতার মধ্যে উল্লেখযোগ্য সম্পর্ক আছে, যা coverage-এর বেলায় দুর্বল; আবার কিছু বাস্তব bug কোনো প্রচলিত mutant-এর সাথে মেলে না। Offutt ও সহকর্মীদের ১৯৯০-এর দশকের কাজ দেখায়, অল্প কয়েকটি operator প্রায় পুরো operator-সমষ্টির মতো ফল দিতে পারে (selective mutation). আর ২০১৫ সালের দিকে Papadakis ও সহকর্মীরা দেখান, compiler-এর optimization-এর পরে machine code মিলিয়ে বহু equivalent আর পরস্পর-নকল mutant সস্তায় বাদ দেওয়া যায় (trivial compiler equivalence). খুঁটিনাটি সংখ্যা মূল প্রবন্ধে দেখুন।

পরীক্ষা ও ইন্টারভিউতে:

  • Mutation testing কী মাপে? Test suite-এর ভুল ধরার ক্ষমতা; কোডের মান নয়।
  • ২০০টি mutant, ১৫০টি killed, ১০টি equivalent — score? ১৫০ ÷ (২০০ − ১০) ≈ ৭৮.৯%.
  • Killed আর survived-এর পার্থক্য? অন্তত একটি test লাল হলে killed; সব সবুজ থাকলে survived.
  • Equivalent mutant কেন সমস্যা? কোনো test মারতে পারে না, আর স্বয়ংক্রিয়ভাবে সাধারণভাবে চেনা অসম্ভব; মানুষের বিচার লাগে।
  • ১০০% coverage থাকলে mutation score কি ১০০%? না; assertion দুর্বল বা সীমার মান না থাকলে বহু mutant বাঁচে।

৯ · AI-এর যুগে mutation testing

AI সহকারী মিনিটে কুড়িটি test লিখে দেয়, আর বলে “সব test পাস, coverage ৯৫%”. এই পর্বের শিক্ষা সেই দাবির সবচেয়ে কার্যকর যাচাই। AI-এর লেখা test-এ প্রচলিত দুর্বলতা: শুধু happy path; সীমার মান বাদ; কোড পড়ে তার বর্তমান আচরণই assert করা, ফলে ভুল কোডেও পাস করে; এত mock যে আসল code-under-test চলেই না (পর্ব ২৪, Test double); sleep দিয়ে অপেক্ষার মতো flaky অভ্যাস; tool-এর এমন option বানানো যা নেই; আর না চালিয়ে “সব পাস” দাবি। এর প্রতিটিই mutation run-এ survivor হিসেবে ধরা পড়ে, বা baseline-এই ধরা পড়ে।

উল্টো দিকে, AI survivor বিশ্লেষণে ভালো সহকারী হতে পারে: diff দেখে কোন input আলাদা করবে তা প্রস্তাব করা, বা equivalent হওয়ার যুক্তি খসড়া করা। শর্ত একটাই: expected মান আসবে requirement থেকে, আর চূড়ান্ত বিচার আপনার।

Survivor রিপোর্ট থেকে requirement-ভিত্তিক test চাইতে পারেন এভাবে:

তুমি একজন অভিজ্ঞ QA engineer. নিচে বাজারঘরের pricing.py, তার লিখিত requirement আর cosmic-ray-এর survivor রিপোর্ট (diff সহ) দিলাম। [requirement পেস্ট করুন] [pricing.py পেস্ট করুন] [cr-report --surviving-only --show-diff-এর আউটপুট পেস্ট করুন] ১. প্রতিটি survivor-কে কারণ ধরে দলে ভাগ করো, আর বলো এটি requirement-এর কোন বাক্যের আচরণ। ২. প্রতিটি দলের জন্য এমন input দাও যা আসল কোড আর mutant-কে আলাদা করে; প্রতিটির expected মান requirement থেকে নাও, কোড থেকে নয়, আর পাশে লেখো কোন বাক্য থেকে এলো। ৩. কোনো survivor equivalent মনে হলে যুক্তি দাও, আর একটি input-জগৎ প্রস্তাব করো যেখানে আমি নিজে খুঁজে দেখতে পারি। ৪. pytest test লেখো, প্রতিটিতে একটি আচরণ, স্পষ্ট নাম। কোনো tool option ব্যবহার করলে নাম আলাদা করে লেখো, আমি docs-এ মিলিয়ে নেব। ৫. নিজে test বা mutation চালানোর দাবি করো না; আমি চালিয়ে ফল জানাব।

AI-এর test হাতে পেলে — চেকলিস্ট

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন — তারপর “→ উত্তর” চাপুন।

প্র ০১Mutation testing ১৯৭০-এর দশকের ধারণা। এত পুরোনো হয়েও শিল্পে কেন এত দেরিতে ছড়াল?

প্রধান কারণ খরচ। ১৯৭৮ সালের DeMillo, Lipton ও Sayward-এর প্রবন্ধের সময়ে কম্পিউটার সময় ছিল দুর্লভ আর দামি। প্রতিটি mutant-এর জন্য পুরো test suite আবার চালাতে হয়; সেকালে অনেক জায়গায় প্রতিটি mutant আলাদা করে compile-ও করতে হতো। ১৯৮০-এর দশকে Mothra-র মতো গবেষণা-system এই খরচ কমাতে interpreter-ভিত্তিক কৌশল নেয়, তবু ব্যবহার মূলত গবেষণাগারে সীমিত ছিল। দ্বিতীয় কারণ, তখন স্বয়ংক্রিয় unit test নিজেই সাধারণ চর্চা ছিল না। যে দলের automated suite নেই, তার কাছে “suite-এর শক্তি মাপা” অর্থহীন প্রশ্ন।

পরের কয়েক দশকে তিনটি বদল ছবিটি পাল্টায়। এক, xUnit পরিবারের framework আর TDD-র প্রসারে প্রায় প্রতিটি প্রকল্পে automated test এল। দুই, কম্পিউটার অনেক দ্রুত আর সস্তা হলো, আর CI-তে সমান্তরালে কাজ চালানো স্বাভাবিক হলো। তিন, tool-গুলো চালাক হলো: bytecode-এ সরাসরি mutant বানানো (compile বাঁচে), coverage দেখে শুধু প্রাসঙ্গিক test চালানো, আর বদলানো লাইনে সীমিত রাখা। PIT-এর মতো tool Java-তে, Stryker JavaScript-এ এই কৌশলগুলোকে সাধারণ দলের নাগালে এনেছে।

শেষ ধাপটি ছিল মানসিক। পুরো codebase-এর একটি score দেখে কেউ কাজের দিক পান না; ৭৪টির মধ্যে ১১টি survivor-এর তালিকা দেখেও প্রথমে বিভ্রান্তি আসে। Google-এর বর্ণিত পদ্ধতি (Petrović ও Ivanković, ২০১৮) মূলত এই সমস্যার সমাধান: score নয়, code review-এর সময় বদলানো লাইনের অল্প কয়েকটি বাছাই করা survivor, ঠিক যখন developer সেই কোডের কথা ভাবছেন। আজ mutation testing-কে অনেকে কম ব্যবহৃত কিন্তু পরিণত কৌশল হিসেবে দেখেন।

মূল উপলব্ধি: একটি ভালো ধারণা ছড়াতে শুধু সঠিক হওয়া যথেষ্ট নয়; খরচ, অবকাঠামো আর কাজের ধারায় খাপ খাওয়াও লাগে। Mutation testing-কে ছোট, লক্ষ্যভেদী আর সময়মতো রাখুন।

প্র ০২ছোট কৃত্রিম ভুল ধরতে পারা কি সত্যিই বাস্তব bug ধরতে পারার প্রমাণ?

এটি mutation testing-এর মৌলিক প্রশ্ন, আর উত্তর “অনেকটা, কিন্তু পুরোপুরি নয়”। দুটি ভিত্তি-অনুমানের প্রথমটি, competent programmer hypothesis, বলে বাস্তব ভুল সাধারণত সঠিক কোডের কাছাকাছি। বাজারঘরের seeded bug-গুলো দেখুন: coupon_ge হলো >-এর জায়গায় >=, delivery_after_discount হলো তুলনার ভিত্তি ভুল মান। প্রথমটি হুবহু একটি ROR mutant; দ্বিতীয়টি কোনো একক operator দিয়ে তৈরি হয় না, কারণ সেখানে একটি variable-এর বদলে অন্য একটি হিসাব বসেছে।

দ্বিতীয় অনুমান, coupling effect, পরীক্ষা করেছিলেন Jeff Offutt ১৯৮০-৯০-এর দশকে: যে suite সব first-order mutant মারে, সে higher-order mutant-এর প্রায় সবই মারে, এমন প্রমাণ তাঁর পরীক্ষায় পাওয়া গেছে বলে উদ্ধৃত হয়। আরও সরাসরি প্রমাণ আসে ২০১৪ সালে René Just ও সহকর্মীদের কাজ থেকে: বাস্তব Java প্রকল্পের সত্যিকারের bug সংগ্রহ করে (Defects4J নামের সংকলন) তাঁরা দেখান, যে test suite বেশি mutant মারে, সে বাস্তব bug-ও বেশি ধরার প্রবণতা দেখায়, আর সম্পর্কটি coverage-এর চেয়ে জোরালো।

সীমাগুলোও স্পষ্ট। Requirement-এ আছে কিন্তু কোডে নেই এমন আচরণ (missing code) কোনো mutant তৈরি করতে পারে না: Plus সদস্যের নিয়ম কেউ না লিখলে সেই লাইনের mutant-ই নেই। Requirement নিজেই ভুল হলে, বা দুই module-এর মধ্যে বোঝাপড়ার ভুল হলে, একক ফাইলের mutation তা দেখে না। Concurrency-র ভুল (পর্ব ৬২-এর বিষয়) আর performance-এর ভুল সাধারণ operator দিয়ে প্রায় তৈরিই হয় না। তাই mutation score উঁচু মানে “যে কোড লেখা আছে, তার ছোট ভুল ধরার ক্ষমতা ভালো”, এর বেশি নয়।

মূল উপলব্ধি: Mutant বাস্তব bug-এর ভালো প্রতিনিধি, কিন্তু সম্পূর্ণ নয়। Mutation testing-কে requirement-ভিত্তিক test নকশা, review আর exploratory testing-এর পরিপূরক হিসেবে দেখুন, বিকল্প হিসেবে নয়।

প্র ০৩Equivalent mutant চেনা কেন মৌলিকভাবে কঠিন, আর বাস্তবে দলগুলো কীভাবে সামলায়?

একটি mutant equivalent কি না জানতে চাওয়া মানে জিজ্ঞাসা করা: দুটি প্রোগ্রাম কি সব সম্ভাব্য input-এ একই আচরণ করে? সাধারণ প্রোগ্রামের জন্য এই প্রশ্নের উত্তর দেওয়ার কোনো সাধারণ algorithm নেই। কারণটি গণনাতত্ত্বের halting problem-এর আত্মীয়: যদি এমন algorithm থাকত, তাহলে তা দিয়ে কোনো প্রোগ্রাম থামে কি না সেটিও নির্ধারণ করা যেত, যা Alan Turing ১৯৩৬ সালে অসম্ভব দেখিয়েছিলেন। Mutation testing-এর প্রসঙ্গে Timothy Budd ও Dana Angluin ১৯৮২ সালের দিকে এই অসমাধানযোগ্যতা নিয়ে লেখেন বলে উদ্ধৃত হয়।

তবে “সাধারণভাবে অসম্ভব” মানে “প্রায়ই অসম্ভব” নয়। বেশিরভাগ equivalent mutant কয়েকটি পরিচিত ছাঁচে পড়ে: শূন্য যোগ বা গুণের মতো প্রভাবহীন বদল (cart-এর <= থেকে <), loop-এর শর্তে < আর != যখন গণনা এক এক করে বাড়ে, সর্বোচ্চ মান খোঁজায় > আর >= (সমান মান বসালেও ফল একই), আর অপ্রয়োজনীয় শর্ত। এগুলোর জন্য কিছু tool নিয়ম রাখে, আর compiler-ভিত্তিক কৌশল (mutant আর আসল কোডের optimize করা machine code মিলে গেলে বাদ) গবেষণায় উল্লেখযোগ্য অংশ সস্তায় ছেঁটে দিয়েছে বলে জানা যায়।

বাকিগুলোর জন্য মানুষের বিচার। ভালো চর্চা: (১) বিচার লিখে রাখা, কেন equivalent, যাতে পরে কেউ আবার সময় না দেন; (২) tool-এর নির্ধারিত উপায়ে সেই লাইন বা mutant বাদ দেওয়া; (৩) সন্দেহ হলে একটি ছোট input-জগতে দুই রূপ মিলিয়ে দেখা, যেমন §৭-এর ৩৪৩টি cart, যদিও তা প্রমাণ নয়। আর সতর্ক থাকা: is-এর মতো “দেখতে equivalent” mutant আসলে বাস্তব bug-এর শ্রেণি দেখায়।

মূল উপলব্ধি: Equivalent mutant mutation testing-এর স্থায়ী খরচ, যা পুরোপুরি স্বয়ংক্রিয় করা যাবে না। লক্ষ্য তাই ১০০% score নয়; লক্ষ্য প্রতিটি survivor-এর একটি সচেতন সিদ্ধান্ত।

প্র ০৪ম্যানেজার বললেন, “এখন থেকে mutation score ৯০%-এর নিচে হলে merge বন্ধ।” আপনি কী পরামর্শ দেবেন?

উদ্দেশ্যটি coverage gate-এর চেয়ে ভালো: অন্তত এমন একটি সংখ্যা যা assertion-হীন test দিয়ে ফাঁকি দেওয়া কঠিন। কিন্তু কড়া gate কয়েকটি সমস্যা ডাকে। প্রথমত, হর অনিশ্চিত: equivalent mutant কোনগুলো তা না জানলে ৯০% কখনো অসম্ভব হতে পারে, বিশেষ করে ছোট ফাইলে যেখানে দুটি equivalent-ই কয়েক শতাংশ। দ্বিতীয়ত, Goodhart-এর নিয়ম: সংখ্যা লক্ষ্য হলে মানুষ সংখ্যাটিই পূরণ করে। Survivor মারতে implementation-এর খুঁটিনাটি assert করা test লেখা যায়, যেমন private হিসাবের মধ্যবর্তী মান, যা পরে প্রতিটি refactor-এ ভাঙে আর কোনো requirement রক্ষা করে না। তৃতীয়ত, সময়: প্রতিটি PR-এ পুরো module-এর mutation run দলকে ধীর করে, আর মানুষ gate এড়ানোর পথ খোঁজে।

বিকল্প প্রস্তাব কয়েকটি। এক, টাকা-জড়িত module (বাজারঘরের pricing, refund, stock) বেছে নিয়মিত রাতের run, আর survivor-এর তালিকা সাপ্তাহিক review-এ। দুই, PR-এ শুধু বদলানো লাইনের mutation, survivor মন্তব্য হিসেবে, merge আটকানো নয়: Google-এর বর্ণিত পদ্ধতিও মূলত এমন। তিন, প্রবণতা দেখা: module-এর score কমতে থাকলে আলোচনা। চার, equivalent হিসেবে চিহ্নিত mutant-এর তালিকা রাখা, যাতে সংখ্যাটি বিশ্বাসযোগ্য হয়।

আর ম্যানেজারকে বোঝানোর ভালো উপায় এই পর্বের ডেটা: একই ১০০% coverage-এ বাজারঘরের suite-এর score ৮৫.১% থেকে ১০০% হয়েছে মাত্র আটটি লক্ষ্যভেদী test-এ, যেগুলোর প্রত্যেকটি একটি বাস্তব ঝুঁকি রক্ষা করে, যেমন ১০০০ টাকার ছাড়, ২০০০ টাকার ফ্রি delivery আর খালি cart. সংখ্যা নয়, সেই তালিকাই মূল্যবান।

মূল উপলব্ধি: Mutation score-কে দরজা নয়, টর্চলাইট বানান: কোথায় test অন্ধ, তা দেখাতে। সিদ্ধান্ত হোক survivor-এর তালিকা দেখে।

প্র ০৫কোড না লিখে একজন manual tester mutation-এর ধারণা কীভাবে কাজে লাগাতে পারেন?

Mutation-এর মূল প্রশ্নটি কোডের বাইরেও খাটে: “কোন ভুল হলে আমার test case ধরবে না?” পুরোনো একটি পদ্ধতি হলো defect seeding বা fault seeding: ইচ্ছা করে জানা কয়েকটি ভুল বসিয়ে দেখা পরীক্ষকেরা কতগুলো খুঁজে পান। ১৯৭০-এর দশকে Harlan Mills এর পরিসংখ্যানভিত্তিক ব্যবহার প্রস্তাব করেন বলে উদ্ধৃত হয়: বসানো ভুলের কত অংশ ধরা পড়ল, তা থেকে আসল ভুলের অবশিষ্ট সংখ্যা আন্দাজ করা। Tom Gilb এর একটি রূপকে “bebugging” নামে বর্ণনা করেছিলেন বলে জানা যায়। হিসাবের এই ব্যবহার বিতর্কিত, কারণ বসানো ভুল আর আসল ভুল একই রকম লুকানো থাকে না; কিন্তু শেখানো আর review-এর মান যাচাইয়ের জন্য ধারণাটি কার্যকর।

দৈনন্দিন কাজে manual tester তিনভাবে লাভ নিতে পারেন। প্রথমত, test case review-এ “mutant-এর চোখ”: প্রতিটি test case পড়ে জিজ্ঞাসা করুন, developer যদি এখানে “বেশি”-র বদলে “বেশি বা সমান” লেখেন, বা ঢাকার বদলে অন্য জেলায় নিয়ম খাটান, কোন test case ধরবে? উত্তর না থাকলে নতুন test case. এটি আসলে মাথার ভেতরে চালানো ROR আর সংখ্যা বদলের operator. দ্বিতীয়ত, staging-এ বা প্রশিক্ষণে seeded bug: বাজারঘরের app-এ যেমন bug switch আছে (coupon_ge, delivery_after_discount), তা চালু করে দেখা আপনার regression checklist ধরে কি না। তৃতীয়ত, developer-এর mutation রিপোর্ট পড়া: survivor-এর diff সাধারণত একটি লাইন, আর “কোন input আলাদা করে” প্রশ্নের উত্তর দিতে BVA আর partition-এর জ্ঞানই লাগে, যা manual tester-এর শক্তির জায়গা।

ক্যারিয়ারের দিক থেকেও এটি সেতু। SDET বা automation-এর ইন্টারভিউতে “coverage আর mutation score-এর পার্থক্য” আর “equivalent mutant” প্রচলিত প্রশ্ন, আর উত্তরের সবচেয়ে বিশ্বাসযোগ্য অংশ হয় নিজের করা একটি ছোট উদাহরণ।

মূল উপলব্ধি: Mutation testing একটি tool-এর আগে একটি অভ্যাস: প্রতিটি test-কে জিজ্ঞাসা করা, “কোন ভুল এই test ধরবে না?” সেই প্রশ্ন কোড ছাড়াও করা যায়।

অনুশীলন

উত্তর দেখার আগে কাগজে নিজে করুন। সব সংখ্যা scratch script-এ মেলানো।

  1. Test নকশা (spec থেকে): বাজারঘরের review-এর লেখা ছাঁটার পরে ১০ থেকে ৫০০ অক্ষর হতে হবে (দুই সীমাই বৈধ)। কোড: return 10 <= n <= 500. Tool সাতটি mutant দিল: (ক) 10 < n <= 500, (খ) 10 <= n < 500, (গ) 11 <= n <= 500, (ঘ) 10 <= n <= 501, (ঙ) 9 <= n <= 500, (চ) 10 <= n <= 499, (ছ) 10 <= n or n <= 500. সবচেয়ে কম কয়টি n-এর মানে সাতটিই মারা যায়, আর কোনগুলো?

    চারটি মান লাগে: n = 9, 10, 500, 501 (expected: মিথ্যা, সত্য, সত্য, মিথ্যা)। কে কাকে মারে: 10 মারে (ক) আর (গ); 500 মারে (খ) আর (চ); 501 মারে (ঘ); 9 মারে (ঙ); (ছ) সবসময় সত্য দেয়, তাই 9 বা 501 দুটোই মারে। (ঙ)-এর জন্য 9 আর (ঘ)-এর জন্য 501 অপরিহার্য, (ক)/(গ)-এর জন্য 10, (খ)/(চ)-এর জন্য 500; তাই তিনটিতে হয় না। Scratch-এ ০, ৫, ৯, ১০, ১১, ২৫০, ৪৯৯, ৫০০, ৫০১, ১০০০ থেকে সব উপসেট খুঁজে দেখা গেছে: তিন বা কম মানের কোনো সেট সাতটি মারে না, চার মানের ঠিক একটি সেট মারে, আর সেটি এই চারটিই। লক্ষ্য করুন, এগুলো হুবহু পর্ব ০৮-এর দুই-মান BVA-র মান।

  2. ফল আগে বলুন (predict): বাজারঘরের stock কমানোর function: if qty > stock: raise NotEnoughStock, তারপর return stock - qty. Test দুটি: (stock 10, qty 3) → 7, আর (stock 2, qty 5) → NotEnoughStock. দুটি mutant: M1 qty >= stock, M2 stock + qty. কোনটি killed, কোনটি survived? Survivor মারতে কোন test যোগ করবেন, আর সেই test mutant-এর ওপর চললে কী দেখা যাবে?

    M2 killed: (10, 3)-এ 13 আসে, expected 7. M1 survived: (10, 3)-এ 3 ≥ 10 মিথ্যা, তাই 7; (2, 5)-এ 5 ≥ 2 সত্য, তাই exception, যা expected-ই। পার্থক্য শুধু qty == stock-এ। নতুন test: (stock 3, qty 3) → 0, অর্থাৎ শেষ তিনটি দুধের প্যাকেট কেনা যাবে। M1-এ এই test-এ NotEnoughStock ওঠে, তাই test লাল হয় একটি অপ্রত্যাশিত exception-এ (assert-এর আগেই), আর mutant killed. Scratch-এ মেলানো: আসল ফল 0, M1-এ exception, M2-তে 6. ব্যবসার দিক থেকে এটি গুরুত্বপূর্ণ সীমা: ভুল কোড শেষ স্টকটি কখনো বিক্রি করতে দিত না।

  3. Test-এ ভুল খুঁজুন: একজন সহকর্মী coupon-এর জন্য নিচের test লিখে জানালেন, “coverage ১০০%, কিন্তু mutation tool বলছে এই test একটিও mutant মারে না। Tool-এ নিশ্চয়ই bug আছে।” Test-এ কী সমস্যা, আর ঠিক রূপ কী?
    def test_coupon_rules():
        for subtotal in (500, 1000, 1500, 5000):
            try:
                assert coupon_discount(subtotal) >= 0
            except AssertionError:
                print("check coupon for", subtotal)

    তিনটি সমস্যা। (১) try/except AssertionError ব্যর্থতাকে গিলে ফেলে শুধু print করে, তাই test কখনো লাল হয় না; tool-এর চোখে এটি সবসময় সবুজ, আর সবুজ test কোনো mutant মারে না। (২) >= 0 দুর্বল oracle: ১০০০-এ ১০০ বা ১৫০০-এ ১৪৯ এলেও পাস করত। (৩) এক test-এ চারটি আচরণ, নামও অস্পষ্ট (পর্ব ২২-এর একটি test, একটি আচরণ)। ঠিক রূপ: প্রতিটি মানের জন্য আলাদা test বা pytest.mark.parametrize, হুবহু expected মান নিয়ম থেকে: 500 → 0, 1000 → 0, 1500 → 150, 5000 → 300; সাথে 1001 → 100. Tool-এ bug নেই; tool ঠিক এই ধরনের অন্ধ test খুঁজে বের করার জন্যই।

  4. Equivalent না আসল ফাঁক? বাজারঘরের admin পাতায় cart-এর সর্বোচ্চ পরিমাণ খোঁজার function: best = 0; প্রতিটি q-এর জন্য if q > best: best = q; return best. তিনটি survivor: M1 q >= best, M2 best = 1, M3 best = -1. প্রতিটি equivalent কি না বলুন; না হলে কোন input মারবে?

    M1 equivalent: সমান মান পেলে আবার একই মান বসে, ফল বদলায় না। Scratch-এ ০ থেকে ৩-এর সংখ্যায় খালি থেকে তিন উপাদানের ৮৫টি তালিকায় একটিতেও পার্থক্য নেই, আর যুক্তিও তাই বলে। M2 আসল ফাঁক: খালি তালিকা বা সব শূন্যের তালিকায় ([], [0], [0, 0]…) mutant দেয় 1, আসল দেয় 0; ৮৫টির ৪টিতে পার্থক্য। M3-ও আসল ফাঁক, শুধু খালি তালিকায়: −1 বনাম 0. তাই একটিমাত্র test, max_qty([]) == 0, M2 আর M3 দুটোকেই মারে; M1-কে equivalent হিসেবে চিহ্ন দিন। শিক্ষা: খালি তালিকা, অর্থাৎ loop-এর শূন্য ঘূর্ণন (পর্ব ১৩-এর loop coverage), প্রায়ই survivor মারে।

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রমএকটি module-এ mutation testing-এর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. আসল কোডে পুরো suite সবুজ কি না যাচাই (baseline)
  2. Mutation operator দিয়ে mutant-এর তালিকা তৈরি
  3. প্রতিটি mutant-এ suite চালানো, সময়সীমাসহ
  4. ফলকে killed, survived, timeout-এ ভাগ করে score হিসাব
  5. প্রতিটি survivor বিচার: equivalent, নাকি test-এর ফাঁক
  6. Requirement থেকে নতুন test লিখে আবার চালানো

একটি mutation run-এ ১২০টি mutant: ৯০টি killed, ৩০টি survived. পরে বিচার করে দেখা গেল survivor-দের ১০টি equivalent. Mutation score কত?

  • ৭৫%
  • প্রায় ৮১.৮%
  • ৯০%
  • ৩৩.৩%

কোড: if qty <= 0: continue, তারপর total += price * qty (cart-এর মোট)। কোন mutant equivalent?

  • if qty <= 0 থেকে if qty <= 1
  • price * qty থেকে price + qty
  • if qty <= 0 থেকে if qty < 0
  • continue থেকে break

একটি suite-এর statement coverage ১০০%, কিন্তু mutation score ০%. সবচেয়ে সম্ভাব্য কারণ কী?

  • Test-গুলো কোড চালায় কিন্তু ফল যাচাই করে না (assertion নেই বা দুর্বল)
  • সব mutant equivalent
  • Mutant-এর লাইনগুলো কোনো test-এ চলেনি
  • সব mutant timeout হয়েছে

Mutation tool subtotal > 1000-কে subtotal >= 1000 বানাল। এটি কোন শ্রেণির operator, আর কোন test কৌশল এই ধরনের mutant মারে?

  • AOR; decision table testing
  • শর্ত উল্টানো (LCR); state transition testing
  • Statement মোছা; pairwise testing
  • ROR; boundary value analysis

একটি mutant loop-এর i += 1-কে i -= 1 করায় test আর শেষ হয় না, আর tool সময়সীমায় থামায়। বেশিরভাগ mutation tool এই ফলকে কীভাবে গোনে?

  • Survived হিসেবে
  • Killed (ধরা পড়েছে) হিসেবে
  • Equivalent হিসেবে
  • হিসাবের বাইরে, চালানো যায়নি এমন mutant হিসেবে

বড় codebase-এ প্রতিটি pull request-এর জন্য mutation testing চালাতে চাইলে সবচেয়ে ব্যবহারিক কৌশল কোনটি?

  • প্রতিটি PR-এ পুরো codebase-এর সব mutant চালানো
  • Mutation বাদ দিয়ে শুধু coverage ৯০%-এর gate রাখা
  • শুধু বদলানো লাইনে অল্প কয়েকটি mutant, survivor review-এর মন্তব্যে
  • Mutation score ১০০% না হলে merge বন্ধ

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. Mutant = আসল কোড + একটি ছোট বদল; কোনো test লাল হলে killed, সব সবুজ হলে survived. উদ্দেশ্য test-এর দুর্বলতা খোঁজা।
  2. প্রচলিত operator: ROR (> ↔ >=), AOR (// ↔ /), সংখ্যায় ±১, not যোগ, statement মোছা।
  3. Mutation score = killed ÷ (মোট − equivalent); timeout সাধারণত killed. বাজারঘরে coverage ১০০% রেখেই ৮৫.১% থেকে ১০০%.
  4. Survivor-এর উত্তর সাধারণত সীমার মান, শূন্য, “অগোল” মান বা default argument-এর test; expected সবসময় requirement থেকে।
  5. Equivalent mutant স্বয়ংক্রিয়ভাবে সাধারণভাবে চেনা অসম্ভব; খরচ বেশি, তাই গুরুত্বপূর্ণ module, বদলানো লাইন আর রাতের run.

পরের পর্বে: এখানে কোডে ভুল বসিয়ে test পরীক্ষা করলেন। এবার উল্টো দিক: program-এ লাখো এলোমেলো আর অদ্ভুত input ছুড়ে crash খোঁজা, fuzz testing, যেখানে coverage নিজেই নতুন input খোঁজার পথ দেখায়।

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান