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

White-box testing — statement, branch, condition আর MC/DC coverage

White-Box Testing — Statement, Branch, Condition and MC/DC Coverage

Taught in Bangla, this lesson draws a control-flow graph from Bazarghar delivery code and counts statement and branch coverage items, then compares condition, condition/decision and MC/DC, picking n plus one MC/DC tests and catching a seeded defect with unittest in in-page Python. It computes cyclomatic complexity and loop coverage. A real coverage.py 7.17.3 and pytest 9.2.0 run reports 85 percent statement and 66.7 percent branch coverage, then 100 percent, while a >= bug still survives.

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

  • কোড থেকে control-flow graph আঁকা, আর তা থেকে statement ও branch coverage item গোনা
  • Condition, condition/decision আর MC/DC-র পার্থক্য; তিন শর্তের decision-এ n + 1টি MC/DC test বাছাই
  • MC/DC টেবিলকে আসল unittest-এ রূপ দিয়ে একটি বসানো ভুল ধরা
  • Path coverage, cyclomatic complexity আর loop coverage-এর হিসাব, আর পথ কেন বিস্ফোরিত হয়
  • coverage.py আর pytest দিয়ে নিজের কম্পিউটারে branch রিপোর্ট বানানো ও পড়া, আর coverage যা বলে না তা চেনা

১ · White-box testing — কোডের ভেতর দেখে test

বাড়িতে নতুন বিদ্যুতের লাইন টানা হলো। মালিক প্রতিটি সুইচ টিপে দেখলেন বাতি জ্বলে কি না: এটি বাইরে থেকে যাচাই। কিন্তু অভিজ্ঞ মিস্ত্রি বোর্ডের নকশা হাতে নিয়ে প্রতিটি সার্কিট ধরে ধরে দেখেন: কোন তারে কখনো বিদ্যুৎ যায়নি, কোন ফিউজ কখনো পরীক্ষা হয়নি। সুইচ সব কাজ করলেও সিঁড়ির বাতির দ্বিতীয় সুইচটি হয়তো কেউ কখনো টেপেননি। দুই রকম যাচাই একে অপরের পরিপূরক।

মডিউল ২-এর আগের পর্বগুলো (পর্ব ০৭ থেকে পর্ব ১২) ছিল black-box কৌশল: requirement পড়ে test নকশা, কোড না দেখে। এই পর্বে মিস্ত্রির চোখ। White-box testing (ISTQB-এর syllabus-এ “white-box test technique”) test নকশা করে বা মাপে কোডের ভেতরের গঠন দেখে: কোন লাইন, কোন শাখা, কোন শর্ত, কোন পথ। প্রতিটি কৌশল একটি করে coverage item-এর তালিকা দেয়, আর মাপ সবসময় একই সূত্রে:

Coverage (%) = ছোঁয়া coverage item ÷ মোট coverage item × ১০০
item = statement, branch, condition, independence pair, path… কৌশল অনুযায়ী

সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৫০-এ coverage আর complexity-র সংজ্ঞা আর একটি পরীক্ষার ফলের function দিয়ে প্রথম পরিচয় হয়েছে। এখানে আরও গভীরে যাব, বাজারঘরের পরিচিত নিয়ম দিয়ে: প্রতিটি কৌশলের ধাপে ধাপে পদ্ধতি, MC/DC test set বাছাই আর যাচাই, loop coverage, নিজের হাতে বানানো ছোট coverage tool, আর একটি আসল tool-এর রিপোর্ট লাইন ধরে পড়া।

বাজারঘরের নিয়ম (এই পর্বে)

Coupon: অর্ডার ১০০০ টাকার বেশি হলে ১০% ছাড়, সর্বোচ্চ ৩০০ টাকা; ছাড় পূর্ণ টাকায়। Delivery charge: ঢাকার ভেতরে ৬০ টাকা, ২০০০ টাকা বা বেশি হলে ফ্রি; ঢাকার বাইরে ১২০ টাকা, Plus সদস্যের ৬০ টাকা। Cart: প্রতিটি লাইনের দাম × পরিমাণ যোগ হয়, পরিমাণ শূন্য বা কম হলে লাইনটি বাদ। নতুন, শুধু এই পর্বে: “ফ্রি ডেলিভারি সপ্তাহ” চললে সবার delivery ফ্রি; অর্থাৎ ফ্রি delivery-র শর্ত (ঢাকা and ≥ 2000) or promo_week.

Glenford Myers-এর The Art of Software Testing (১৯৭৯) statement, decision, condition আর multiple-condition coverage-কে “logic coverage”-এর ধাপ হিসেবে সাজিয়েছিল। Thomas McCabe ১৯৭৬ সালে cyclomatic complexity প্রস্তাব করেন। MC/DC এসেছে বিমান শিল্প থেকে: RTCA-র DO-178B (১৯৯২) নির্দেশিকায়, আর John Chilenski ও Steven Miller-এর ১৯৯৪ সালের প্রবন্ধে এর ব্যাখ্যা ও যুক্তি। Python-এর সবচেয়ে প্রচলিত coverage tool coverage.py প্রথমে লিখেছিলেন Gareth Rees; ২০০৪ সাল থেকে Ned Batchelder এটি বাড়িয়ে চলেছেন ও রক্ষণাবেক্ষণ করছেন।

White-box কৌশল সবচেয়ে বেশি কাজে লাগে unit test-এর স্তরে (পর্ব ০৫), যেখানে কোড ছোট আর পুরোটা দেখা যায়। তবে ধারণাটি ওপরের স্তরেও খাটে: API-র কোন endpoint কোনো test-এ ডাকা হয়নি, মেনুর কোন পাতা কেউ খোলেননি, এগুলোও coverage. Manual tester-এর জন্যও এই পর্ব জরুরি: developer-এর coverage রিপোর্ট পড়তে পারলে আপনি বলতে পারবেন কোন আচরণ এখনো যাচাই হয়নি, আর সেখানে black-box test নকশা করবেন।

২ · Control-flow graph — delivery charge-এর কোড থেকে ছবি

সব white-box মাপের ভিত্তি control-flow graph (CFG): কোডের কোন অংশের পরে কোন অংশ চলতে পারে, তার ছবি। নিয়মগুলো সংক্ষেপে:

  • Node: একটি basic block, অর্থাৎ পরপর চলা statement-এর দল যাতে ঢোকা যায় শুধু প্রথম লাইনে, বের হওয়া যায় শুধু শেষ লাইনে।
  • Edge: তীর, এক block শেষে নিয়ন্ত্রণ কোথায় যেতে পারে।
  • Decision node: যেখান থেকে দুই বা বেশি তীর বের হয়: if, while, for-এর শর্ত। দুই দিকের তীরে T আর F লেখা হয়।
  • Entry আর exit: function-এ ঢোকার আর বের হওয়ার জায়গা। একাধিক return থাকলে সবগুলো একটি exit node-এ মেলানো হয়।

কাজের ধারা — পাঁচ ধাপে CFG

  1. Function-এর executable লাইনগুলো নম্বর দিন (ঘোষণা আর docstring বাদ)।
  2. পরপর চলা লাইন যেখানে কোনো শাখা বা লাফ নেই, সেগুলো এক node-এ রাখুন।
  3. প্রতিটি শর্তকে decision node বানান, T আর F দিকের তীর আঁকুন।
  4. যেখানে পথ আবার মেলে (if-এর শেষে, loop-এর মাথায়, exit-এ), সেখানে তীর মেলান। Loop-এর শেষ থেকে মাথায় ফেরার তীর হলো back edge.
  5. Node (N), edge (E) আর decision গুনে লিখুন; পরের অংশগুলোর সব হিসাব এখান থেকে।

এবার বাজারঘরের delivery_charge. বাঁয়ে কোড, ডানে CFG ধাপে ধাপে তৈরি হচ্ছে। “পরে” চাপুন:

1def delivery_charge(district, total, member=False):2    if district == "Dhaka":3        if total >= 2000:4            return 05        return 606    if member:7        return 608    return 120
delivery_charge-এর CFG: ৮টি node, ১০টি edge, ৩টি decision T F T F T F 1 2 5 3 4 6 7 8 entry exit
  1. Node ১ — জেলার শর্ত। লাইন ২-এর if function-এর প্রথম executable লাইন, তাই এটিই entry. এখান থেকে দুটি তীর বের হবে, তাই এটি decision node (কমলা)।
  2. Node ২ — টাকার শর্ত। জেলা ঢাকা হলে (T) নিয়ন্ত্রণ যায় লাইন ৩-এ, total >= 2000. এটিও decision, সবুজ T তীর ১ → ২.
  3. Node ৩ আর ৪ — ঢাকার দুই ফল। T দিকে লাইন ৪ (return 0), F দিকে লাইন ৫ (return 60). দুটিই সাধারণ block (নীল)।
  4. Node ৫ — সদস্যের শর্ত। জেলা ঢাকা না হলে (F) নিয়ন্ত্রণ সোজা লাইন ৬-এ, if member. তৃতীয় decision.
  5. Node ৬ আর ৭ — বাইরের দুই ফল। সদস্য হলে লাইন ৭ (return 60), না হলে লাইন ৮ (return 120).
  6. Node ৮ — exit, আর গোনা। চারটি return-ই exit-এ মেলে। মোট N = ৮টি node, E = ১০টি edge, decision ৩টি। entry থেকে exit পর্যন্ত পথ ঠিক ৪টি, কারণ graph-এ কোনো loop নেই। §৬-এ এই সংখ্যাগুলো কোডে মিলিয়ে দেখবেন।

যুক্ত শর্ত কীভাবে আঁকবেন? Python-এর and/or short-circuit: a and b-এ a মিথ্যা হলে b দেখাই হয় না। তাই নিখুঁত CFG-তে if a and b দুটি decision node. Decision-স্তরের ছবিতে একটি node আঁকা হয়। খাতায় কোনটি আঁকছেন স্পষ্ট লিখুন, কারণ §৬-এর complexity-র সংখ্যা এতে বদলায়।

৩ · Statement আর branch coverage — গোনা, সূত্র আর নিজের হাতে মাপা

Statement coverage

Statement coverage: প্রতিটি executable statement অন্তত একবার চলেছে কি না। Coverage item = statement; CFG-তে প্রতিটি node ছোঁয়া। delivery_charge-এ item ৭টি (লাইন ২–৮)।

Branch coverage

Branch coverage: প্রতিটি decision-এর প্রতিটি ফল অন্তত একবার নেওয়া হয়েছে কি না। Item = decision node থেকে বের হওয়া তীর। এখানে ৩ × ২ = ৬টি। ISTQB v4 এগুলোকে বলে branch; পুরোনো বইয়ে decision coverage প্রায় সমার্থক।

পদ্ধতি দুটিরই এক: (১) CFG আঁকুন; (২) item-এর তালিকা লিখুন; (৩) প্রতিটি test কোন item ছোঁয়, চিহ্ন দিন; (৪) না-ছোঁয়া item-এর জন্য এমন input খুঁজুন যা সেই পথে যায়; (৫) expected result লিখুন requirement থেকে, কোড থেকে নয়। শেষ কথাটি গুরুত্বপূর্ণ: white-box কৌশল বলে কোন পথে input পাঠাতে হবে, কিন্তু সঠিক উত্তর কী, তা বলে test oracle, অর্থাৎ নিয়ম।

নিচের stepper-এ দুটি test দিয়ে শুরু করি, যেগুলো একজন নতুন tester সহজেই লিখতেন: ঢাকায় বড় অর্ডার আর বাইরে ছোট অর্ডার।

delivery_charge: ৭টি statement, ৬টি branch
test
চলা লাইন
নেওয়া branch
statement
branch
  1. শুরু। CFG থেকে item তালিকা: statement লাইন ২ থেকে ৮, সাতটি; branch ছয়টি: 2→3, 2→6, 3→4, 3→5, 6→7, 6→8. প্রতিটি তীরের প্রথম সংখ্যা decision-এর লাইন, দ্বিতীয়টি যে লাইনে যায়।
  2. Test ১: ঢাকা, ২৫০০ টাকা। লাইন ২ সত্য, লাইন ৩ সত্য, লাইন ৪-এ ফ্রি। চলল তিনটি লাইন, নেওয়া হলো দুটি তীর। Statement ৩/৭ = ৪২.৯%, branch ২/৬ = ৩৩.৩%.
  3. Test ২: রাজশাহী, ৫০০ টাকা। লাইন ২ মিথ্যা, তাই 2→6; সদস্য নন, তাই 6→8, ১২০ টাকা। নতুন দুটি লাইন আর দুটি তীর। মোট statement ৫/৭ = ৭১.৪%, branch ৪/৬ = ৬৬.৭%.
  4. ফাঁক পড়া। না-চলা লাইন ৫ আর ৭: “ঢাকায় ছোট অর্ডার” আর “বাইরের Plus সদস্য”। দুটি নিয়মই requirement-এ আছে, অথচ কোনো test সেগুলো চালায়নি। White-box মাপ এখানে আসল কাজটি করল: নির্দিষ্ট করে দেখাল কোন আচরণ যাচাই হয়নি।
  5. দুটি test যোগ। ঢাকা, ১৫০০ টাকা (expected ৬০) চালায় 3→5; সিলেট, ৫০০ টাকা, সদস্য (expected ৬০) চালায় 6→7. এখন statement আর branch দুটিই ১০০%. খেয়াল করুন, expected মান দুটি এসেছে নিয়ম থেকে; কোড শুধু বলেছে কোন input লাগবে।

এই হিসাবটি এখন একটি ছোট Python প্রোগ্রাম নিজে করবে, ঠিক যেভাবে একটি coverage tool করে। প্রোগ্রামটি দুটি কাজ করে। প্রথমে কোডের syntax tree (ast) থেকে কোন লাইন statement আর কোন তীর branch, সেই তালিকা বানায়: coverage.py-ও তার “সম্ভাব্য তীর”-এর তালিকা এভাবে স্থিরভাবে বিশ্লেষণ করে বের করে। তারপর sys.settrace দিয়ে প্রতিটি চলা লাইন আর পরপর দুটি লাইনের জোড়া (arc) রেকর্ড করে; এই কাজকে বলে instrumentation. প্রতিটি test-এর পরে জমা হিসাব ছাপা হয়। “চালান” চাপুন; প্রথমবার ব্রাউজারে Pyodide (ব্রাউজারের Python) নামতে কয়েক সেকেন্ড লাগে।

import ast, sys
SRC = '''def delivery_charge(district, total, member=False):
    if district == "Dhaka":
        if total >= 2000:
            return 0
        return 60
    if member:
        return 60
    return 120
'''
fn = ast.parse(SRC).body[0]
STMTS = {n.lineno for n in ast.walk(fn) if isinstance(n, ast.stmt)} - {fn.lineno}
BRANCHES = set()                      # (if line, first line of T side / F side)
def scan(body):
    for i, s in enumerate(body):
        if isinstance(s, ast.If):     # (here no if is the last statement)
            f_side = s.orelse[0] if s.orelse else body[i + 1]
            BRANCHES.update({(s.lineno, s.body[0].lineno), (s.lineno, f_side.lineno)})
            scan(s.body); scan(s.orelse)
scan(fn.body)
ns = {}; exec(compile(SRC, "pricing.py", "exec"), ns)
lines, arcs, prev = set(), set(), [None]
def tracer(frame, event, arg):
    if frame.f_code.co_name != "delivery_charge": return None
    if event == "line":
        lines.add(frame.f_lineno)
        if prev[0]: arcs.add((prev[0], frame.f_lineno))
        prev[0] = frame.f_lineno
    return tracer
for test in [("Dhaka", 2500), ("Rajshahi", 500), ("Dhaka", 1500), ("Sylhet", 500, True)]:
    prev[0] = None; sys.settrace(tracer); out = ns["delivery_charge"](*test); sys.settrace(None)
    s, b = len(lines & STMTS), len(arcs & BRANCHES)
    print(f"{test} -> {out}")
    print(f"  stmt {s}/{len(STMTS)} = {100*s/len(STMTS):.1f}%  branch {b}/{len(BRANCHES)} = {100*b/len(BRANCHES):.1f}%")
    print(f"  missing lines {sorted(STMTS - lines)}  arcs {sorted(BRANCHES - arcs)}")

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

('Dhaka', 2500) -> 0
  stmt 3/7 = 42.9%  branch 2/6 = 33.3%
  missing lines [5, 6, 7, 8]  arcs [(2, 6), (3, 5), (6, 7), (6, 8)]
('Rajshahi', 500) -> 120
  stmt 5/7 = 71.4%  branch 4/6 = 66.7%
  missing lines [5, 7]  arcs [(3, 5), (6, 7)]
('Dhaka', 1500) -> 60
  stmt 6/7 = 85.7%  branch 5/6 = 83.3%
  missing lines [7]  arcs [(6, 7)]
('Sylhet', 500, True) -> 60
  stmt 7/7 = 100.0%  branch 6/6 = 100.0%
  missing lines []  arcs []

প্রথম দুটি test-এর পরের সংখ্যা stepper-এর সাথে হুবহু মেলে: ৫/৭ আর ৪/৬, বাকি লাইন ৫ আর ৭, বাকি তীর (3, 5) আর (6, 7). STMTS আর BRANCHES কেউ হাতে লেখেনি, কোড থেকে বের হয়েছে; এখানে প্রতিটি if-এর পরে আরেকটি statement আছে বলে F দিক সহজে পাওয়া গেছে। আসল tool আরও অনেক কিছু সামলায়: else-হীন if, loop-এর back edge, exception, একই লাইনে লেখা শর্ত। আরেকটি জিনিস খেয়াল করুন: test-গুলো কিছুই assert করছে না, শুধু ডাকছে। Coverage বেড়েছে, অথচ একটি ফলও যাচাই হয়নি; §৮-এ এই ফাঁদে ফিরব।

Statement ১০০%, branch কম — কখন হয়

else-হীন if-এ। বাজারঘরের coupon কোড যদি লেখা হয় discount = 0, তারপর if total > 1000: discount = …, তারপর return discount, তাহলে ১৫০০ টাকার একটি test-ই সব লাইন চালায়: statement ১০০%. কিন্তু “শর্ত মিথ্যা” তীরটি কোনো আলাদা লাইনে যায় না, সরাসরি return-এ যায়; তাই statement coverage তাকে দেখে না, branch ৫০%. এজন্য branch coverage statement coverage-কে subsume করে (branch ১০০% মানে statement ১০০%), উল্টোটা নয়। §৭-এ আসল tool ঠিক এই তীরটি 7->9 লিখে দেখাবে।

৪ · Condition, condition/decision আর MC/DC

একটি decision (পুরো if-এর শর্ত) কয়েকটি condition দিয়ে তৈরি হতে পারে, যেগুলো আর ভাঙা যায় না। বাজারঘরের ফ্রি delivery: (district == "Dhaka" and total >= 2000) or promo_week. এখানে decision একটি, condition তিনটি: A = জেলা ঢাকা, B = মোট ২০০০ বা বেশি, C = ফ্রি ডেলিভারি সপ্তাহ। Branch coverage শুধু পুরো decision-এর T/F দেখে; ভেতরের কোন condition কী ভূমিকা রাখল, দেখে না। তাই শর্তের স্তরে চারটি মাপকাঠি:

মাপকাঠিCoverage item(A and B) or C-এ ন্যূনতম
Condition coverageপ্রতিটি condition-এর T আর F মান২: যেমন TTF, FFT; কিন্তু decision coverage নিশ্চিত নয়
Condition/decisionওপরেরটি + decision-এর দুই ফল২: TTT আর FFF
MC/DCপ্রতিটি condition-এর একটি independence pair৪ (n + 1)
Multiple-conditionসব সমন্বয়2³ = ৮

সারির ক্রমে TTF মানে A = সত্য, B = সত্য, C = মিথ্যা। Independence pair হলো এমন দুটি test, যেখানে শুধু একটি condition-এর মান আলাদা, বাকিগুলো একই, আর decision-এর ফলও আলাদা। এমন জোড়া প্রমাণ করে যে ওই condition নিজে একা ফল বদলাতে পারে, অর্থাৎ কোডে তার উপস্থিতি অর্থবহ; আর কেউ সেটি ভুল লিখলে (যেমন and-এর জায়গায় or) কোনো test ধরবে।

কাজের ধারা — MC/DC set বাছাই

  1. Decision-এর truth table লিখুন: n condition-এ 2ⁿ সারি, প্রতিটির ফল।
  2. প্রতিটি condition-এর জন্য সব independence pair খুঁজুন: এক condition বদলালে ফল বদলায় এমন সারির জোড়া।
  3. যে condition-এর জোড়া মাত্র একটি, সেই জোড়ার দুই সারি বাধ্যতামূলক; আগে সেগুলো নিন।
  4. বাকি condition-এর জন্য এমন জোড়া বাছুন, যার একটি সারি আগেই নেওয়া আছে; এতে নতুন test মাত্র একটি লাগে।
  5. শেষে যাচাই: প্রতিটি condition-এর জোড়া set-এর ভেতরেই আছে কি না। সাধারণ গঠনে n + 1টি test যথেষ্ট হয়; কিছু গঠনে বেশি লাগে, তবে প্রতিটি condition-এর জোড়া থাকলে 2n-এর বেশি লাগে না।
A = ঢাকা · B = ≥ 2000 · C = promo_week
ধাপ
দেখা যাচ্ছে
test সংখ্যা
  1. Truth table. তিন condition-এ ৮টি সারি। A and B সত্য হলে, অথবা C সত্য হলে ফল সত্য। ৮টির মধ্যে ৫টিতে ফ্রি delivery.
  2. A-র জোড়া। A বদলালে ফল বদলায় শুধু তখন, যখন B সত্য আর C মিথ্যা: FTF (ফল F) আর TTF (ফল T). C সত্য হলে or এমনিতেই সত্য, আর B মিথ্যা হলে and এমনিতেই মিথ্যা; এভাবে একটি condition অন্যটির প্রভাব ঢেকে দেওয়াকে বলে masking.
  3. B-র জোড়া। একইভাবে একটিই: TFF আর TTF. A-র জোড়ার সাথে TTF সারিটি ভাগাভাগি হচ্ছে, তাই তিনটি সারিতেই A আর B দুটোর প্রমাণ।
  4. C-র জোড়া। A and B মিথ্যা থাকলে C-ই ফল ঠিক করে, তাই তিনটি জোড়া। আগে নেওয়া FTF বা TFF-এর সাথী আছে (FTT, TFT), তাই নতুন test মাত্র একটি লাগবে।
  5. Set বাছাই। TTF, FTF, TFF বাধ্যতামূলক; C-র জন্য TFT যোগ করলে জোড়া TFF ↔ TFT. মোট ৪ = n + 1. ন্যূনতম set ঠিক দুটি: {TTF, FTF, TFF, TFT} আর {TTF, FTF, TFF, FTT}; scratch script-এ সব ৮টি সারির সব উপসেট খুঁজে মেলানো হয়েছে।
  6. তুলনা। Decision coverage-এ ২টি test (একটি T, একটি F), condition/decision-এ ২টি (TTT, FFF), MC/DC-তে ৪টি, সব সমন্বয়ে ৮টি। ১০টি condition হলে শেষ মাপকাঠিতে ১০২৪টি, অথচ and-এর সরল শৃঙ্খলে MC/DC-তে ১১টি।

হাতে খুঁজলে ভুল হয়, তাই এবার উল্টো দিকের কাজ: একটি দেওয়া test set MC/DC পূরণ করে কি না, যাচাই করা। Review-এ সহকর্মীর test set দেখে ঠিক এই প্রশ্নই করবেন। নিচের checker চারটি set-এর জন্য decision, condition আর MC/DC (unique-cause) আলাদা করে বিচার করে, আর প্রতিটি condition-এর কোন জোড়া পাওয়া গেল তা দেখায়:

from itertools import combinations

def D(a, b, c):                       # (A and B) or C
    return int(bool((a and b) or c))

def row(t):                           # "TTF" -> (1, 1, 0)
    return tuple(int(ch == "T") for ch in t)

def check(tests):
    rows = [row(t) for t in tests]
    outs = {D(*r) for r in rows}
    cond_ok = all({r[k] for r in rows} == {0, 1} for k in range(3))
    shown = {}
    for r, s in combinations(rows, 2):   # unique-cause independence pair
        diff = [k for k in range(3) if r[k] != s[k]]
        if len(diff) == 1 and D(*r) != D(*s):
            shown.setdefault("ABC"[diff[0]], (r, s))
    fmt = lambda r: "".join("TF"[1 - v] for v in r)
    print(f"{' '.join(tests):16} decision {'ok' if outs == {0, 1} else 'NO'}"
          f" | condition {'ok' if cond_ok else 'NO'}"
          f" | MC/DC {len(shown)}/3 = {100 * len(shown) / 3:.0f}%")
    for name in "ABC":
        pair = shown.get(name)
        print(f"   {name}: " + (f"{fmt(pair[0])} vs {fmt(pair[1])}" if pair else "no pair"))

for tests in (["TTF", "FFF"], ["TTT", "FFF"],
              ["TTF", "FTF", "TFF", "FFT"], ["TTF", "FTF", "TFF", "TFT"]):
    check(tests)

আসল আউটপুট:

TTF FFF          decision ok | condition NO | MC/DC 0/3 = 0%
   A: no pair
   B: no pair
   C: no pair
TTT FFF          decision ok | condition ok | MC/DC 0/3 = 0%
   A: no pair
   B: no pair
   C: no pair
TTF FTF TFF FFT  decision ok | condition ok | MC/DC 2/3 = 67%
   A: TTF vs FTF
   B: TTF vs TFF
   C: no pair
TTF FTF TFF TFT  decision ok | condition ok | MC/DC 3/3 = 100%
   A: TTF vs FTF
   B: TTF vs TFF
   C: TFF vs TFT

প্রথম set (TTF, FFF) decision coverage দেয়, কিন্তু C দুবারই মিথ্যা, তাই condition coverage-ও নয়। দ্বিতীয় set (TTT, FFF) condition/decision পূরণ করে, অথচ MC/DC শূন্য: দুই test-এ তিনটি condition একসাথে বদলেছে, তাই কোনটি ফল বদলাল বলা যায় না। তৃতীয় set-এ চারটি test আছে, তবু C-র জোড়া নেই: FFT-এর সাথী FFF set-এ নেই। “চারটি test আছে, তাই MC/DC” ভাবা ভুল; সংখ্যা নয়, জোড়া গুনুন। চতুর্থ set stepper-এর বাছাই, ১০০%. MC/DC coverage-এর হিসাব এখানে “প্রমাণিত condition ÷ মোট condition”, যা coverage item-এর সাধারণ সূত্রই।

Unique-cause, masking আর short-circuit

ওপরের checker unique-cause MC/DC মানে: জোড়ায় ঠিক একটি condition বদলায়। কিছু গঠনে এটি অসম্ভব, যেমন একই condition দুবার থাকলে ((A and B) or (A and C)). তখন masking MC/DC ব্যবহার হয়: অন্য condition-ও বদলাতে পারে, যদি সেই বদল ফলকে ছুঁতে না পারে। যেমন A-র জন্য TTF আর FFF: B-ও বদলেছে, কিন্তু A মিথ্যা হলে B-র মান আর গণ্য হয় না। আরেকটি বাস্তব খুঁটিনাটি: Python-এ TTF-এ C আদৌ মূল্যায়ন হয় না, কারণ A and B সত্য হতেই or থেমে যায়। তাই কোন সংজ্ঞা মানছেন, খাতায় বা test plan-এ লিখে রাখুন। Byte-code স্তরে প্রতিটি short-circuit লাফ একটি আলাদা branch, তাই এমন ভাষায় branch coverage আর condition-স্তরের coverage-এর মধ্যে দূরত্ব কিছুটা কমে।

Coverage মাপকাঠির সিঁড়ি

Subsumption ladder: each box guarantees every box below it on the main line

Multiple-condition → MC/DC → condition/decision → branch → statement; condition/decision → condition Multiple-condition · 8 MC/DC · 4 Condition/decision · 2 Branch · 2 Statement · 1 Condition · 2 নিচে তীর নেই
ছবি ১৩.১ — তীর মানে “পূরণ করলে নিচেরটিও পূরণ হয়”। সংখ্যা: (A and B) or C-এ ন্যূনতম test. Statement-এ ১টি: TTF-এর মতো একটি সত্য ফলেই if-এর body চলে (এখানে else নেই ধরে)। Condition coverage আলাদা বাক্সে, কারণ সে branch বা statement নিশ্চিত করে না।

৫ · MC/DC টেবিল থেকে আসল unittest — বসানো ভুল ধরা

Test case টেবিল আগে, কোড পরে। ফ্রি delivery-র নিয়ম থেকে MC/DC set, প্রতিটি সারির expected result requirement থেকে:

IDজেলা, মোট, promoA B CExpectedCoverage item
FD-1Dhaka, 2500, FalseT T Fফ্রি (True)A, B-র জোড়ার সাধারণ সারি
FD-2Khulna, 2500, FalseF T Fফ্রি নয় (False)A-র জোড়া (FD-1-এর সাথে)
FD-3Dhaka, 1500, FalseT F Fফ্রি নয় (False)B-র জোড়া (FD-1), C-র জোড়া (FD-4)
FD-4Dhaka, 1500, TrueT F Tফ্রি (True)C-র জোড়া

এবার টেবিলটিকে unittest-এ রূপ দিই, আর দুটি কোডের ওপর চালাই: সঠিক কোড, আর একটি বসানো ভুলসহ কোড, যেখানে developer and-এর জায়গায় or লিখে ফেলেছেন। তুলনার জন্য শুধু decision coverage দেওয়া দুই-সারির set (TTF, FFF)-ও চালানো হচ্ছে। প্রতিটি সারি একটি subTest, তাই এক সারি fail করলেও বাকিগুলো চলে।

import io, unittest

def free_delivery(district, total, promo_week):
    return (district == "Dhaka" and total >= 2000) or promo_week

def free_delivery_seeded(district, total, promo_week):   # seeded defect
    return (district == "Dhaka" or total >= 2000) or promo_week

DECISION_SET = [("Dhaka", 2500, False, True),    # TTF
                ("Khulna", 1500, False, False)]  # FFF
MCDC_SET = [("Dhaka", 2500, False, True),        # TTF  A, B pairs
            ("Khulna", 2500, False, False),      # FTF  A pair
            ("Dhaka", 1500, False, False),       # TFF  B, C pairs
            ("Dhaka", 1500, True, True)]         # TFT  C pair

def make_suite(func, table):
    class FreeDeliveryTest(unittest.TestCase):
        def test_table(self):
            for district, total, promo, expected in table:
                with self.subTest(district=district, total=total, promo=promo):
                    self.assertEqual(func(district, total, promo), expected)
    return unittest.defaultTestLoader.loadTestsFromTestCase(FreeDeliveryTest)

for name, func in [("correct", free_delivery), ("seeded", free_delivery_seeded)]:
    for set_name, table in [("decision set", DECISION_SET), ("MC/DC set", MCDC_SET)]:
        result = unittest.TextTestRunner(stream=io.StringIO()).run(make_suite(func, table))
        print(f"{name:7} code, {set_name:12}: {len(table)} rows, {len(result.failures)} failed")
        for test, tb in result.failures:
            print("    FAIL", dict(test.params), "->", tb.strip().splitlines()[-1])

আসল আউটপুট:

correct code, decision set: 2 rows, 0 failed
correct code, MC/DC set   : 4 rows, 0 failed
seeded  code, decision set: 2 rows, 0 failed
seeded  code, MC/DC set   : 4 rows, 2 failed
    FAIL {'district': 'Khulna', 'total': 2500, 'promo': False} -> AssertionError: True != False
    FAIL {'district': 'Dhaka', 'total': 1500, 'promo': False} -> AssertionError: True != False

সঠিক কোডে দুই set-ই সবুজ, যা প্রত্যাশিত। ভুল কোডে decision set পুরোপুরি সবুজ: TTF-এ True or True আর True and True দুটিই সত্য, FFF-এ দুটিই মিথ্যা। অর্থাৎ ১০০% decision coverage নিয়েও ভুলটি নিরাপদে production-এ চলে যেত, আর খুলনার ২৫০০ টাকার প্রতিটি অর্ডার ভুল করে ফ্রি delivery পেত। MC/DC set-এ দুটি সারি লাল: FD-2 (খুলনা, ২৫০০) আর FD-3 (ঢাকা, ১৫০০); দুটিই A বা B-র independence pair-এর অংশ। True != False পড়ার নিয়ম: প্রথমটি কোড যা দিল, দ্বিতীয়টি expected. Unique-cause জোড়া এমনভাবে তৈরি যে একটি condition একা ফল বদলায়; তাই সেই condition-কে ঘিরে and/or উল্টে গেলে জোড়ার অন্তত একটি সারির ফল বদলে যায়।

৬ · Path coverage, cyclomatic complexity আর loop coverage

Path coverage চায় entry থেকে exit পর্যন্ত প্রতিটি সম্ভাব্য পথ। Loop-হীন কোডে পথ গোনা যায়, কিন্তু loop থাকলে প্রতিটি ঘূর্ণন নতুন পথ বানায়। আবার কিছু পথ graph-এ আঁকা গেলেও কোনো input-এ চলে না, কারণ শর্তগুলো পরস্পর-নির্ভর; এদের বলে infeasible path. তাই বাস্তবে দুটি সীমিত রূপ ব্যবহার হয়: McCabe-এর basis path আর loop coverage.

Cyclomatic complexity V(G) তিনভাবে বের হয়, আর এক graph-এ তিনটিই এক:

V(G) = E − N + 2 = decision node + 1 = বদ্ধ এলাকা (region) + 1
এক entry, এক exit-এর graph-এ; দুই-মুখী decision ধরে

V(G) হলো স্বাধীন পথের একটি basis set-এর আকার: এতগুলো পথ বাছা যায় যাদের মিলিয়ে graph-এর যেকোনো পথ গঠন করা যায়। প্রতিটির জন্য একটি test দিলে branch coverage-ও পূরণ হয়। নিচের কোড দুটি CFG-কে তালিকা আকারে রেখে N, E, V(G) গোনে, loop-হীন graph-এর সব পথ ছাপে, আর cart_total-এর loop-এ ঘূর্ণন বাড়লে পথ কীভাবে বাড়ে দেখায়। cart_total-এর node: ১ = total = 0, ২ = for-এর মাথা, ৩ = if qty <= 0, ৪ = continue, ৫ = যোগ, ৬ = return.

DELIVERY = {1: [2, 5], 2: [3, 4], 3: [8], 4: [8],     # node: next nodes
            5: [6, 7], 6: [8], 7: [8], 8: []}         # 8 = exit
CART = {1: [2], 2: [3, 6], 3: [4, 5], 4: [2], 5: [2], 6: []}   # 2 = loop head

def metrics(name, g):
    n = len(g); e = sum(len(v) for v in g.values())
    decisions = sum(1 for v in g.values() if len(v) == 2)
    print(f"{name}: N={n} E={e} V(G)=E-N+2={e - n + 2}  decisions+1={decisions + 1}")

def paths(g, node, exit_node, loops_left, head=None):
    if node == exit_node:
        return [[node]]
    found = []
    for nxt in g[node]:
        left = loops_left
        if nxt == head and node != 1:       # back edge into the loop head
            if left == 0:
                continue
            left -= 1
        found += [[node] + p for p in paths(g, nxt, exit_node, left, head)]
    return found

metrics("delivery_charge", DELIVERY)
for p in paths(DELIVERY, 1, 8, 0):
    print("   path", "-".join(map(str, p)))
metrics("cart_total", CART)
for k in range(5):
    print(f"   paths with at most {k} loop turns: {len(paths(CART, 1, 6, k, head=2))}")

আসল আউটপুট:

delivery_charge: N=8 E=10 V(G)=E-N+2=4  decisions+1=4
   path 1-2-3-8
   path 1-2-4-8
   path 1-5-6-8
   path 1-5-7-8
cart_total: N=6 E=7 V(G)=E-N+2=3  decisions+1=3
   paths with at most 0 loop turns: 1
   paths with at most 1 loop turns: 3
   paths with at most 2 loop turns: 7
   paths with at most 3 loop turns: 15
   paths with at most 4 loop turns: 31

delivery_charge-এ তিন সূত্রই ৪, আর পথও ঠিক ৪টি; loop নেই বলে basis path আর সব পথ এখানে এক, আর §৩-এর চারটি test এই চারটি পথই চালায়। cart_total-এ V(G) মাত্র ৩, কিন্তু প্রতিটি ঘূর্ণনে ভেতরে দুটি পথ (বাদ দেওয়া বা যোগ করা), তাই ঠিক k ঘূর্ণনের পথ 2kটি, আর সর্বোচ্চ k পর্যন্ত মোট 2k+1 − 1: ১, ৩, ৭, ১৫, ৩১. Cart-এ ৩০টি লাইন থাকলে পথ একশো কোটির বেশি। Path coverage তাই loop-এ অবাস্তব, আর basis path-এর ৩টি test (যেমন খালি cart, শূন্য পরিমাণের একটি লাইন, সাধারণ একটি লাইন) যথেষ্ট ধরা হয়। কিছু tool যুক্ত শর্তের প্রতিটি and/or-কেও একটি decision গোনে; তখন সংখ্যা বাড়ে।

Loop coverage — কতবার ঘোরালে যথেষ্ট

Loop coverage-এর প্রচলিত নিয়ম (Boris Beizer-এর বইয়ে সাজানো রূপ): একটি সাধারণ loop-এ শূন্যবার, একবার, দুবার, সাধারণ সংখ্যকবার, আর সীমা থাকলে সর্বোচ্চ − ১, সর্বোচ্চ, সর্বোচ্চ + ১ বার। শেষ তিনটি আসলে loop-এর গণনায় boundary value analysis (পর্ব ০৮)। Nested loop-এ ভেতরেরটি থেকে শুরু করুন, বাইরেরগুলো ন্যূনতমে রেখে।

IDitemsঘূর্ণনExpectedকী ধরে
CT-1[]০0শুরুর মান ভুল (যেমন None)
CT-2[(100, 2)]১200গুণের ভুল
CT-3[(100, 0), (80, 3)]২240continue-এর পরে loop চলতে থাকে কি না
CT-4১০টি লাইন, একটি ঋণাত্মক পরিমাণ১০হাতে হিসাব করা যোগফলজমা হওয়ার ভুল, ঋণাত্মক লাইন বাদ

CT-3-এর মতো test বিশেষ জরুরি: প্রথম লাইনে continue হওয়ার পরও দ্বিতীয় লাইন যোগ হয় কি না। ভুল করে continue-এর জায়গায় break লিখলে CT-1 আর CT-2 পাস করবে, শুধু CT-3 ধরবে।

৭ · ডেস্কটপে সত্যিকারের run — coverage.py --branch আর pytest

এবার আসল tool. নিচের সবকিছু এই কোর্সের লেখার সময় একটি সাধারণ Windows ডেস্কটপে সত্যিকারভাবে চালানো হয়েছে: Python 3.12.13, coverage.py 7.17.3 (Apache 2.0 লাইসেন্স), pytest 9.2.0 (MIT লাইসেন্স), uv দিয়ে বানানো একটি ছোট প্রকল্পে; path নিরপেক্ষ করা। pytest-এর পূর্ণ ব্যবহার আসবে পর্ব ২১ (pytest-এর মূল — assert, fixture, parametrize আর marker)-এ; প্রাথমিক পরিচয় Python প্রোগ্রামিং কোর্সের পর্ব ৪২-এ। এখানে শুধু assert লেখা ছোট test লাগবে।

cd ~/bazarghar-qa
uv init --vcs none --author-from none
uv add pytest coverage

কোড: বাজারঘরের pricing module. Report-এ লাইন নম্বর আসবে, তাই ফাইলটি প্রথম লাইন থেকে পুরো দেওয়া হলো (লাইন ১ docstring, লাইন ৪ def coupon_discount).

"""Bazarghar pricing rules (course example)."""


def coupon_discount(total):
    """10% off above 1000 taka, at most 300, whole taka."""
    discount = 0
    if total > 1000:
        discount = min(total // 10, 300)
    return discount


def delivery_charge(district, total, member=False):
    """Dhaka 60 (free from 2000), outside 120 (Plus member 60)."""
    if district == "Dhaka":
        if total >= 2000:
            return 0
        return 60
    if member:
        return 60
    return 120


def cart_total(items):
    """Sum of price * qty; lines with qty <= 0 are skipped."""
    total = 0
    for price, qty in items:
        if qty <= 0:
            continue
        total += price * qty
    return total
from pricing import cart_total, coupon_discount, delivery_charge


def test_coupon_above_1000():
    assert coupon_discount(1500) == 150


def test_delivery_dhaka_big_order():
    assert delivery_charge("Dhaka", 2500) == 0


def test_delivery_outside_dhaka():
    assert delivery_charge("Rajshahi", 500) == 120


def test_cart_two_lines():
    assert cart_total([(100, 2), (50, 1)]) == 250

pyproject.toml-এ [tool.pytest.ini_options]-এর নিচে pythonpath = ["."] লেখা আছে, যাতে test ফাইল pricing খুঁজে পায়। প্রথমে branch ছাড়া, শুধু statement:

$ uv run coverage run --source=pricing -m pytest -q
....                                                [100%]
4 passed in 0.02s
$ uv run coverage report -m
Name         Stmts   Miss  Cover   Missing
------------------------------------------
pricing.py      20      3    85%   17, 19, 28
------------------------------------------
TOTAL           20      3    85%

এবার একই চারটি test, শুধু --branch যোগ করে:

$ uv run coverage erase
$ uv run coverage run --branch --source=pricing -m pytest -q
....                                                [100%]
4 passed in 0.02s
$ uv run coverage report -m
Name         Stmts   Miss Branch BrPart  Cover   Missing
--------------------------------------------------------
pricing.py      20      3     12      4    78%   7->9, 17, 19, 28
--------------------------------------------------------
TOTAL           20      3     12      4    78%

রিপোর্টটি লাইন ধরে পড়া

  • Stmts 20: তিনটি def লাইন আর ১৭টি body-র statement; docstring গোনা হয় না। def লাইনও statement, কারণ module import হওয়ার সময় সেগুলো চলে।
  • Miss 3, Missing 17, 19, 28: ঢাকার ছোট অর্ডারের return 60, সদস্যের return 60, আর continue. §৩-এর stepper-এর লাইন ৫ আর ৭ এখানে লাইন ১৭ আর ১৯; একই দুটি test, একই ফাঁক।
  • Branch 12: coupon-এর if-এ ২, delivery-র তিন if-এ ৬, cart-এর for (ঢোকা আর বের হওয়া) আর if-এ ৪.
  • BrPart 4: চারটি decision-এর এক দিকই নেওয়া হয়েছে (partial branch). লাইন ১৫, ১৮ আর ২৭-এর না-নেওয়া দিক একটি missing লাইনে যায়, তাই তালিকায় আলাদা লেখা হয় না; লাইন নম্বরই যথেষ্ট।
  • 7->9: একমাত্র তীর যার গন্তব্য লাইন নিজে চলেছে: “total > 1000 মিথ্যা হয়ে সরাসরি return discount”. Statement রিপোর্টে coupon পুরো সবুজ ছিল; branch রিপোর্ট দেখাল কোনো test ১০০০ বা কম টাকার অর্ডার পাঠায়নি।
  • Cover 78%: coverage.py statement আর branch মিলিয়ে একটি সংখ্যা দেয়: (১৭ + ৮) ÷ (২০ + ১২) = ২৫ ÷ ৩২ = ৭৮.১%. একই run-এর coverage json আলাদা করে দিয়েছে statement ৮৫%, branch ৮ ÷ ১২ = ৬৬.৭%, আর না-নেওয়া তীর [7, 9], [15, 17], [18, 19], [27, 28].

রিপোর্ট থেকে নতুন test: প্রতিটি না-নেওয়া তীরের জন্য একটি input, expected নিয়ম থেকে। চারটি test যোগ করে (৫০০ টাকার coupon, ঢাকায় ১৫০০, সিলেটের সদস্য, শূন্য পরিমাণের লাইন):

def test_coupon_small_order():
    assert coupon_discount(500) == 0


def test_delivery_dhaka_small_order():
    assert delivery_charge("Dhaka", 1500) == 60


def test_delivery_member_outside():
    assert delivery_charge("Sylhet", 500, member=True) == 60


def test_cart_skips_zero_qty():
    assert cart_total([(100, 0), (80, 3)]) == 240
$ uv run coverage run --branch --source=pricing -m pytest -q
........                                            [100%]
8 passed in 0.03s
$ uv run coverage report -m
Name         Stmts   Miss Branch BrPart  Cover   Missing
--------------------------------------------------------
pricing.py      20      0     12      0   100%
--------------------------------------------------------
TOTAL           20      0     12      0   100%

১০০% branch, তবু ভুল টিকে থাকে

এবার pricing.py-এর লাইন ৭-এ ইচ্ছা করে ভুল বসানো হলো: if total >= 1000:. অর্থাৎ ঠিক ১০০০ টাকায় ১০০ টাকা ছাড়, যা নিয়মবিরুদ্ধ। একই আটটি test:

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

সব সবুজ, coverage ১০০%. ১৫০০ আর ৫০০ দুই দিকের তীর চালায়, কিন্তু কোনোটিই সীমায় বসে নেই। এবার পর্ব ০৮-এর সীমার মান 1000 যোগ করা হলো:

$ uv run pytest -q
........F                                           [100%]
================================ FAILURES ================================
_______________________ test_coupon_boundary_1000 ________________________

    def test_coupon_boundary_1000():
>       assert coupon_discount(1000) == 0
E       assert 100 == 0
E        +  where 100 = coupon_discount(1000)

tests\test_pricing.py:37: AssertionError
======================== short test summary info =========================
FAILED tests/test_pricing.py::test_coupon_boundary_1000 - assert 100 == 0
1 failed, 8 passed in 0.04s

assert 100 == 0: কোড দিল ১০০, নিয়ম চায় ০. ভুল কোড ঠিক করার পর নয়টি test-ই পাস, coverage ১০০%. শিক্ষাটি এই পর্বের সবচেয়ে বড়: coverage বলে কোন পথ চলেছে; কোন মানে চলেছে আর ফল ঠিক ছিল কি না, বলে না। White-box আর black-box কৌশল তাই প্রতিযোগী নয়, জুটি। (পাতায় আঁটাতে এই অংশের সব আউটপুটে সারির ফাঁকা জায়গা আর কিছু = ও _ চিহ্ন ছাঁটা হয়েছে; লেখা অপরিবর্তিত।)

নিজের কাজে ব্যবহার: HTML রিপোর্টের জন্য coverage html (লাল লাইন আর হলুদ partial branch চিহ্নিত পাতা), CI-র জন্য coverage xml বা coverage json, আর নিয়ম বেঁধে দিতে coverage report --fail-under=80. বারবার flag না লিখে pyproject.toml-এ [tool.coverage.run]-এর নিচে branch = true রাখা যায়। CI-তে coverage gate কীভাবে বসাবেন, তা পর্ব ৬৪ আর ৬৭-এ। coverage.py-র ডিফল্ট মাপার ব্যবস্থা Python 3.14 থেকে sys.monitoring (PEP 669), আগের version-এ C-তে লেখা trace function; দুটিই §৩-এর ছোট tracer-এর মতো একই কাজ করে, অনেক দ্রুত।

৮ · Coverage যা বলে না — ফাঁদ, target আর কৌশল বাছাই

Coverage যা ধরতে পারে না: (১) না-লেখা কোড: requirement-এ আছে কিন্তু কোডে নেই, যেমন Plus সদস্যের নিয়মটিই কেউ লেখেননি; যে লাইন নেই, তা কখনো “missing” দেখায় না। (২) ভুল expected মান বা assertion-হীন test. (৩) ভুল মানে চলা পথ, যেমন সীমার বাইরের মান (ওপরের >=)। (৪) Data-নির্ভর ভুল: বাংলা লেখা, বড় সংখ্যা, শূন্য দিয়ে ভাগ। (৫) সময় আর concurrency-র ভুল, পরিবেশ আর configuration-এর ভুল।

Brian Marick-এর পরিচিত প্রবন্ধ “How to Misuse Code Coverage” (১৯৯০-এর দশকের শেষে) মূল কথাটি বলেছিল: না-ছোঁয়া কোড দেখে ভাবুন কোন test নকশা দুর্বল ছিল, শুধু সেই লাইন ছোঁয়ার জন্য test লিখবেন না। সংখ্যাকে লক্ষ্য বানালে সংখ্যা বাড়ে, মান নয় (Goodhart-এর নিয়ম)। assertion ছাড়া test লিখে, বা শুধু function ডেকে, যেকোনো coverage ১০০% করা যায়।

Coverage রিপোর্ট হাতে পেলে — পাঁচ ধাপের অভ্যাস

  1. লাল আর হলুদ আগে, শতাংশ পরে। প্রতিটি না-চলা লাইন বা তীরের পাশে লিখুন সেটি কোন requirement-এর কোন আচরণ।
  2. শ্রেণিভাগ করুন। (ক) যাচাই হওয়া দরকার কিন্তু হয়নি; (খ) প্রায় অসম্ভব পথ, যেমন রক্ষণাত্মক raise; (গ) মৃত কোড, যা মুছে ফেলা উচিত। শুধু (ক)-এর জন্য test লিখুন, (গ) developer-কে জানান।
  3. Test নকশা black-box কৌশলে। না-চলা শাখার শর্ত থেকে partition আর সীমা বের করুন (পর্ব ০৭, ০৮), যুক্ত শর্ত হলে MC/DC জোড়া।
  4. Expected মান requirement থেকে। কোড পড়ে expected লিখলে ভুল কোডকেই সঠিক বলে লিখে ফেলবেন।
  5. ভুল বসিয়ে যাচাই। নতুন test-টি যে আচরণের জন্য লেখা, কোডে সেখানে ছোট একটি ভুল বসিয়ে দেখুন test লাল হয় কি না; তারপর ভুল সরান।

কোন মাপকাঠি কখন

পরিস্থিতিযুক্তিসঙ্গত মাপকাঠি
সাধারণ ব্যবসার কোড (বাজারঘরের বেশিরভাগ)Branch coverage, প্রবণতা দেখে; নতুন কোডে না-ছোঁয়া শাখার কারণ review-এ জিজ্ঞাসা
টাকা, ছাড়, কর, অনুমতির জটিল শর্তBranch + সেই decision-গুলোতে MC/DC, সাথে BVA
নিরাপত্তা-গুরুত্বপূর্ণ (বিমান, গাড়ি, চিকিৎসা)মান-নির্দিষ্ট structural coverage, প্রায়ই MC/DC; নিয়ম মান আর কর্তৃপক্ষ ঠিক করে
Loop-ভারী হিসাবBranch + loop coverage (০, ১, ২, অনেক, সীমা)
Test suite-এর শক্তি মাপাCoverage-এর পাশে mutation score (পর্ব ৫৯)

আরও গভীরে: Inozemtseva ও Holmes (ICSE ২০১৪) বড় Java প্রকল্পে দেখান, test suite-এর আকার নিয়ন্ত্রণ করলে coverage আর ভুল ধরার ক্ষমতার সম্পর্ক দুর্বল থেকে মাঝারি; অর্থাৎ coverage একা মানের ভালো পূর্বাভাস নয়। পরের কিছু গবেষণা ভিন্ন পদ্ধতিতে আরও জোরালো সম্পর্ক পেয়েছে, তাই বিতর্কটি খোলা। মোটামুটি ঐকমত্য: কম coverage নিশ্চিতভাবে খারাপ সংকেত, বেশি coverage ভালোর নিশ্চয়তা নয়। Object code স্তরে MC/DC আর source স্তরে MC/DC এক নয়, compiler শর্ত বদলে দিতে পারে; বিমান শিল্পে এ নিয়ে আলাদা নির্দেশনা আছে।

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

  • else-হীন if, একটি সত্য test — statement আর branch কত? Statement ১০০%, branch ৫০%.
  • n টি condition-এর and শৃঙ্খলে MC/DC-র ন্যূনতম test? n + 1; সব সমন্বয়ে 2ⁿ.
  • Condition coverage কি decision coverage নিশ্চিত করে? না; (T,F) আর (F,T) দিয়ে A and B দুবারই মিথ্যা।
  • N = ৯, E = ১১ হলে V(G)? ১১ − ৯ + ২ = ৪; স্বাধীন পথ ৪টি।
  • ১০০% coverage মানে কি bug নেই? না; coverage চলা মাপে, যাচাই নয়। না-লেখা কোড আর ভুল মান ধরা পড়ে না।

৯ · AI-এর যুগে white-box coverage

“এই ফাইলের coverage ১০০% করে দাও” বললে AI সহকারী মিনিটে কাজটি করে দেয়, আর ঠিক এখানেই বিপদ। Coverage এমন সংখ্যা যা সস্তায় বাড়ানো যায়। AI প্রায়ই যা করে: কোড পড়ে তার বর্তমান আচরণই assert করে, ফলে বসানো >= ভুলটির জন্য সে লিখবে assert coupon_discount(1000) == 100, যা ভুল কোডে পাস করে আর ভুলকে স্থায়ী করে। শুধু happy path, সীমার মান বাদ; এত mock যে আসল কোড চলেই না; coverage.py-র এমন option বানিয়ে বলা যা নেই; আর না চালিয়েই “সব test পাস, coverage ১০০%” দাবি।

AI-কে coverage-এর ফাঁক দেখিয়ে requirement-ভিত্তিক test চাইতে পারেন, কোড-ভিত্তিক নয়:

তুমি একজন অভিজ্ঞ QA engineer. নিচে বাজারঘরের pricing.py, তার requirement আর coverage.py --branch-এর রিপোর্ট দিলাম। [requirement পেস্ট করুন] [pricing.py পেস্ট করুন] [coverage report -m-এর আউটপুট পেস্ট করুন] ১. Missing কলামের প্রতিটি লাইন বা তীর কোন requirement-এর কোন আচরণ, সহজ বাংলায় বলো। ২. প্রতিটির জন্য একটি pytest test দাও, যার expected মান requirement থেকে নেওয়া; কোড থেকে নয়। প্রতিটি expected-এর পাশে requirement-এর কোন বাক্য থেকে এলো লেখো। ৩. যেসব decision-এ and/or আছে, সেগুলোর MC/DC set টেবিলে দাও (A, B, C-র মান আর independence pair). ৪. সীমার মানগুলো আলাদা করে তালিকা দাও। ৫. কোনো coverage.py option ব্যবহার করলে তার নাম লেখো, আমি docs-এ মিলিয়ে নেব। নিজে test চালানোর দাবি করো না।

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

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

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

প্র ০১দলের নিয়ম “coverage ৯০%-এর নিচে হলে merge বন্ধ”। এটি কি ভালো নিয়ম?

নিয়মটির পেছনের উদ্দেশ্য ভালো: না-test করা কোড যেন চুপচাপ ঢুকে না পড়ে। কিন্তু সংখ্যাকে লক্ষ্য বানালে মানুষ সংখ্যাটিই পূরণ করে। Charles Goodhart অর্থনীতিতে যে পর্যবেক্ষণ করেছিলেন, পরে সংক্ষেপে বলা হয় “কোনো মাপ লক্ষ্য হয়ে গেলে ভালো মাপ থাকে না”। Coverage-এ এটি খুব সহজে ঘটে: assertion-হীন test, শুধু function ডেকে ফেলে রাখা test, বা getter-setter-এর মতো তুচ্ছ কোডের test দিয়ে সংখ্যা বাড়ানো যায়, আর জটিল শর্তের কোড অবহেলিত থাকে।

গবেষণাও সাবধান করে। Laura Inozemtseva আর Reid Holmes ২০১৪ সালে (ICSE) বেশ কয়েকটি বড় open-source Java প্রকল্পে দেখান, test suite-এর আকার নিয়ন্ত্রণ করলে coverage আর mutant ধরার ক্ষমতার সম্পর্ক দুর্বল থেকে মাঝারি। পরের কিছু কাজ ভিন্ন ফল পেয়েছে, কিন্তু কেউ দাবি করেন না যে বেশি coverage নিজেই ভালো test-এর প্রমাণ।

ভালো বিকল্প কয়েকটি। প্রথমত, পুরো প্রকল্পের বদলে নতুন বা বদলানো কোডের coverage দেখা (diff coverage), কারণ পুরোনো কোডের ঋণ একদিনে শোধ হয় না। দ্বিতীয়ত, সংখ্যা কমে গেলে merge আটকানো, যাতে প্রবণতা খারাপ না হয় (ratchet). তৃতীয়ত, review-এ প্রশ্ন: “এই লাল লাইনগুলো কেন test হয়নি?” কখনো উত্তর সঙ্গত (log বা আটকে-যাওয়া-অসম্ভব শাখা), কখনো সেখানেই সবচেয়ে ঝুঁকিপূর্ণ নিয়ম। চতুর্থত, গুরুত্বপূর্ণ module-এ mutation score (পর্ব ৫৯) দেখা, যা সরাসরি মাপে test ভুল ধরে কি না।

মূল উপলব্ধি: Coverage-এর সবচেয়ে বিশ্বাসযোগ্য তথ্য হলো কী চলেনি। তাকে আলোচনার শুরু বানান, পাস-ফেলের একমাত্র দরজা নয়।

প্র ০২বিমানের software-এ কেন MC/DC চাওয়া হয়, আর সাধারণ app-এ কেন তা প্রায় দেখা যায় না?

বিমানের flight control বা engine নিয়ন্ত্রণের কোডে অনেক decision কয়েকটি শর্ত মিলিয়ে তৈরি: চাকা মাটিতে কি না, গতি কত, কোন মোড চালু। ভুল একটি and বা উল্টো একটি শর্ত বিপর্যয় ডাকতে পারে। সব সমন্বয় test করা (multiple-condition) শর্ত বাড়লে অসম্ভব: ২০টি শর্তে দশ লাখের বেশি। Branch coverage আবার খুব দুর্বল, কারণ §৫-এ দেখেছেন দুটি test-এ and থেকে or বদল নির্বিঘ্নে পার হয়ে যায়। MC/DC মাঝখানের পথ: প্রতিটি শর্ত একা ফল বদলাতে পারে, তা প্রমাণ করা, মোটামুটি n + 1টি test-এ।

RTCA-র DO-178B (১৯৯২) আর তার উত্তরসূরি DO-178C (২০১১) software-কে ব্যর্থতার পরিণতি অনুযায়ী স্তরে ভাগ করে; সাধারণভাবে উদ্ধৃত রূপে সবচেয়ে গুরুতর Level A-তে MC/DC, Level B-তে decision, Level C-তে statement coverage চাওয়া হয়। Chilenski ও Miller-এর ১৯৯৪ সালের প্রবন্ধ এর যুক্তি দেয়, আর NASA-র ২০০১ সালের Hayhurst ও সহকর্মীদের tutorial প্রয়োগের খুঁটিনাটি ব্যাখ্যা করে। গাড়ির নিরাপত্তা মান ISO 26262-ও সর্বোচ্চ ঝুঁকির স্তরে MC/DC সুপারিশ করে বলে উদ্ধৃত হয়। খুঁটিনাটি মান আর কর্তৃপক্ষের ব্যাখ্যায় নির্ভর করে।

সাধারণ app-এ খরচ-লাভের হিসাব ভিন্ন। প্রতিটি জোড়া খুঁজে test লেখা আর রক্ষণাবেক্ষণ সময় নেয়; ভুলের পরিণতি সাধারণত ঠিক করা যায় এমন। তবে কৌশলটি ছোট পরিসরে খুব কাজের: বাজারঘরের ছাড়, ফ্রি delivery বা refund-এর অনুমতির মতো টাকা-জড়িত জটিল শর্তে কয়েকটি MC/DC test সস্তা বীমা।

মূল উপলব্ধি: মাপকাঠির কড়াকড়ি ঝুঁকির সাথে মেলান। পুরো প্রকল্পে MC/DC নয়, কিন্তু যেখানে একটি and টাকা বা জীবন নিয়ন্ত্রণ করে, সেখানে জোড়া খুঁজুন।

প্র ০৩২০১৪ সালের “goto fail” bug থেকে statement coverage সম্পর্কে কী শেখা যায়?

২০১৪ সালের ফেব্রুয়ারিতে Apple-এর SSL/TLS library (SecureTransport)-তে একটি ছোট কিন্তু গুরুতর ভুল প্রকাশ পায়। C কোডে পরপর দুটি লাইনে একই কথা লেখা ছিল: goto fail;. প্রথমটি একটি if-এর ভেতরে, দ্বিতীয়টি ভুল করে নকল হওয়া, আর বন্ধনী না থাকায় সেটি শর্তহীনভাবে চলত। ফলে সার্ভারের পরিচয়-যাচাইয়ের শেষ ধাপটি কখনো চলত না, অথচ ফলাফল “সফল” হিসেবে ফিরত। এতে নির্দিষ্ট পরিস্থিতিতে নকল সার্ভার নিরাপদ সংযোগের ভান করতে পারত।

লক্ষ্য করুন, ভুলটির পরের যাচাইয়ের কোড কোনো পথেই পৌঁছানো যেত না: সেটি dead code হয়ে গিয়েছিল। যেকোনো statement coverage রিপোর্টে লাইনগুলো লাল দেখাত, test যত বেশিই হোক। অর্থাৎ এখানে সবচেয়ে দুর্বল মাপকাঠিও একটি নিশ্চিত সংকেত দিত: “এই গুরুত্বপূর্ণ যাচাই কখনো চলেনি।” একইভাবে compiler-এর unreachable-code সতর্কবার্তা বা static analysis (পর্ব ০৬) এটি ধরতে পারত, আর বন্ধনী বাধ্যতামূলক করার মতো coding নিয়মও প্রতিরোধ করত। ঘটনাটি নিয়ে অনেক বিশ্লেষণ লেখা হয়েছে; এখানে শুধু মূল প্রক্রিয়াটি বলা হলো।

উল্টো দিকটিও গুরুত্বপূর্ণ। লাল লাইন দেখা তখনই কাজে আসে, যখন কেউ রিপোর্ট পড়েন আর জিজ্ঞাসা করেন “কেন?” একটি বড় ফাইলে ৯৫% coverage দেখে কেউ সন্তুষ্ট হলে বাকি ৫%-এর মধ্যেই এমন লাইন লুকিয়ে থাকতে পারে। তাই নিরাপত্তা-সংবেদনশীল কোডে না-চলা লাইনের তালিকা পড়া আলাদা একটি review কাজ।

মূল উপলব্ধি: Coverage-এর শক্তি তার নেতিবাচক তথ্যে: কী একবারও চলেনি। সংখ্যা নয়, লাল লাইনগুলো পড়ুন।

প্র ০৪Cyclomatic complexity কি শুধু test-এর হিসাব, নাকি কোডের নকশা সম্পর্কেও কিছু বলে?

Thomas McCabe ১৯৭৬ সালে IEEE Transactions on Software Engineering-এ “A Complexity Measure” প্রকাশ করেন। মূল ধারণা graph তত্ত্ব থেকে: একটি সংযুক্ত graph-এর স্বাধীন চক্রের সংখ্যা E − N + P (P = আলাদা অংশ)। Exit থেকে entry-তে একটি কাল্পনিক তীর জুড়ে দিলে এক function-এর CFG-তে এটি হয় E − N + 2. Graph-এর মৌলিক ধারণা বিচ্ছিন্ন গণিত কোর্সের পর্ব ৫৭-এ।

Test-এর দিক থেকে V(G) বলে basis path-এর সংখ্যা, অর্থাৎ branch coverage-এর জন্য প্রয়োজনীয় test-এর একটি ঊর্ধ্বসীমা-ধরনের সংখ্যা। delivery_charge-এ ৪, আর ঠিক ৪টি test-এ ১০০% branch পাওয়া গেছে। নকশার দিক থেকে, McCabe নিজে প্রতি module-এ ১০-কে যুক্তিসঙ্গত ঊর্ধ্বসীমা প্রস্তাব করেছিলেন; অনেক linter আজও এমন সীমায় সতর্ক করে। বেশি complexity মানে বেশি পথ, বোঝা কঠিন, test বেশি, আর পরিবর্তনে ঝুঁকি বেশি।

সীমাও আছে। ১০টি case-এর একটি সরল match V(G)-তে বড় সংখ্যা দেয়, অথচ পড়া সহজ; আবার nested loop আর ভাঙা নিয়ন্ত্রণের কোড কম সংখ্যাতেও বোঝা কঠিন। এজন্য পরে cognitive complexity-র মতো মাপ এসেছে, যা nesting-কে বেশি ভার দেয়। আরও মনে রাখুন, V(G) পথের সম্ভাব্যতা জানে না: infeasible path থাকলে basis set-এর কোনো পথের জন্য input-ই থাকে না, আর সাধারণভাবে কোন পথ সম্ভব তা স্বয়ংক্রিয়ভাবে নির্ধারণ করা গণনাতত্ত্বে অসমাধানযোগ্য সমস্যার শ্রেণিতে পড়ে।

মূল উপলব্ধি: V(G) একসাথে test-এর বাজেট আর নকশার সতর্কসংকেত। উঁচু সংখ্যা দেখলে আগে ভাবুন function ভাঙা যায় কি না; তারপর test লিখুন।

প্র ০৫White-box test লিখতে কি developer হতে হয়? Manual tester এই পর্ব থেকে কী নেবেন?

White-box কৌশলের দুটি ভাগ: নকশা (কোড দেখে input বাছাই) আর মাপ (চালানো test কোন অংশ ছুঁল)। নকশার জন্য কোড পড়তে পারা লাগে; ছোট function পড়ার মতো Python এই কোর্সের মডিউল ৪ থেকে কাজে লাগবে। কিন্তু মাপ পড়ার জন্য programmer হওয়া জরুরি নয়। coverage.py-র HTML রিপোর্টে লাল লাইনের পাশে কোড আর একটি নাম থাকে, যেমন delivery_charge-এর return 60. একজন manual tester এটি দেখে বলতে পারেন: “ঢাকার ভেতরে ছোট অর্ডারের delivery charge কোনো automated test-এ যাচাই হয়নি; আমি নিয়মটি জানি, এর জন্য test case লিখছি।”

এভাবে দুই দলের মধ্যে একটি সেতু তৈরি হয়। Developer-এর unit test যে আচরণ ছোঁয়নি, tester সেখানে black-box কৌশল (partition, boundary, decision table) প্রয়োগ করেন। আবার tester-এর exploratory session-এর পরে coverage চালালে দেখা যায় কোন কোড কেউ ছোঁয়নি; অনেক দল manual test-এর সময়েও coverage রেকর্ড করে, যদিও তা সবসময় সহজ নয়।

ক্যারিয়ারের দিক থেকেও এটি গুরুত্বপূর্ণ। SDET বা automation-এর দিকে যেতে চাইলে coverage রিপোর্ট পড়া, branch আর MC/DC-র পার্থক্য বোঝা, আর CI-তে coverage gate নিয়ে যুক্তি দেওয়া প্রায় নিয়মিত কাজ। ইন্টারভিউতেও “statement বনাম branch” আর “১০০% coverage মানে কি bug নেই” প্রশ্ন খুব প্রচলিত।

মূল উপলব্ধি: White-box মানে কোড লেখা নয়, কোডের ছবি থেকে প্রশ্ন তোলা। রিপোর্টের প্রতিটি লাল দাগ একটি না-জিজ্ঞাসা করা প্রশ্ন।

অনুশীলন

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

  1. MC/DC নকশা: বাজারঘরে cash on delivery চলবে যদি A and (B or C): A = অর্ডার ১০,০০০ টাকা বা কম, B = গ্রাহকের ফোন যাচাই করা, C = আগে অন্তত একটি অর্ডার নেওয়া। (ক) প্রতিটি condition-এর independence pair লিখুন। (খ) একটি ন্যূনতম MC/DC set দিন। (গ) কয়টি test, আর multiple-condition-এ কয়টি?

    (ক) ফল সত্য শুধু TFT, TTF, TTT-এ। A-র জোড়া তিনটি: FFT ↔ TFT, FTF ↔ TTF, FTT ↔ TTT (B বা C সত্য থাকলেই A নির্ধারক)। B-র একটি: TFF ↔ TTF. C-র একটি: TFF ↔ TFT.

    (খ) B আর C-র জোড়া বাধ্যতামূলক: TFF, TTF, TFT. A-র জন্য TTF-এর সাথী FTF বা TFT-এর সাথী FFT. যেমন {FTF, TFF, TFT, TTF}; অন্য ন্যূনতম set {FFT, TFF, TFT, TTF}. Concrete রূপে একটি: (১৫,০০০, যাচাই, নতুন) → না; (৫,০০০, অযাচাই, নতুন) → না; (৫,০০০, অযাচাই, পুরোনো) → হ্যাঁ; (৫,০০০, যাচাই, নতুন) → হ্যাঁ।

    (গ) ৪টি = n + 1; সব সমন্বয়ে ৮টি। সীমা ১০,০০০-এর জন্য BVA আলাদা করে যোগ করুন (১০,০০০ আর ১০,০০১)।

  2. রিপোর্ট পড়ুন (predict): §৭-এর pricing.py-তে পাঁচটি test চালানো হলো: coupon 1500 আর 500; delivery Dhaka 2500 আর Rajshahi 500; cart [(100, 0), (80, 3)]. coverage report -m (branch সহ) কী দেখাবে: Miss, BrPart, Cover আর Missing? কোন দুটি test যোগ করবেন?

    সত্যিকারের run-এর ফল:

    Name         Stmts   Miss Branch BrPart  Cover   Missing
    --------------------------------------------------------
    pricing.py      20      2     12      2    88%   17, 19

    Coupon-এর দুই দিক আর cart-এর continue এখন চলেছে। না-চলা লাইন ১৭ আর ১৯; partial branch দুটি (লাইন ১৫ আর ১৮), যাদের না-নেওয়া দিক ঠিক ওই missing লাইনেই যায়, তাই আলাদা তীর লেখা নেই। Cover = (১৮ + ১০) ÷ ৩২ = ৮৭.৫%, রিপোর্টে গোল করে ৮৮%. যোগ করুন: delivery_charge("Dhaka", 1500) == 60 আর delivery_charge("Sylhet", 500, member=True) == 60.

  3. Test-এ ভুল খুঁজুন: একজন সহকর্মী cart_total-এর জন্য নিচের test লিখে জানালেন, “branch coverage ১০০%, কাজ শেষ।” Test-টিতে কী সমস্যা, আর কীভাবে ঠিক করবেন?
    def test_cart_all_paths():
        result = cart_total([(100, 0), (80, 3)])
        assert result >= 0
        assert cart_total([]) is not None

    Coverage দাবি সত্য: খালি cart (loop-এ না ঢোকা), শূন্য পরিমাণ (continue) আর সাধারণ লাইন, সব তীর চলে। কিন্তু assertion প্রায় কিছুই যাচাই করে না। result >= 0 পাস করবে যদি কোড 0, 80 বা 99999 দেয়; continue-এর জায়গায় break লিখলে ফল 0, তবু পাস। is not None খালি cart-এর 0 যাচাই করে না। ঠিক রূপ: assert cart_total([(100, 0), (80, 3)]) == 240 আর assert cart_total([]) == 0, expected requirement থেকে হিসাব করে। প্রমাণ করতে break বসিয়ে দেখুন নতুন test লাল হয় কি না। শিক্ষা: coverage চালানো মাপে, যাচাই নয়।

  4. Complexity গুনুন: নিচের OTP-যাচাই function-এর decision-স্তরে V(G) কত? প্রতিটি and-কে আলাদা decision ধরলে কত? Branch coverage-এর জন্য ন্যূনতম কয়টি test লাগবে বলে আশা করবেন, আর loop coverage-এ কোন ঘূর্ণন সংখ্যাগুলো নেবেন?
    def otp_check(codes, expected):
        for attempt, code in enumerate(codes, 1):
            if attempt > 3:
                return "locked"
            if code == expected and len(code) == 6:
                return "ok"
        return "failed"

    Decision তিনটি (for, দুটি if), তাই V(G) = ৩ + ১ = ৪. and-কে আলাদা ধরলে ৫ (scratch-এ ast দিয়ে গোনা)। Branch-এর জন্য basis path অনুযায়ী ৪টির কাছাকাছি test: খালি তালিকা ("failed", loop-এ ঢোকা হয় না), প্রথমবারেই সঠিক কোড ("ok"), ভুল কোড দিয়ে শেষ ("failed"), চারটি ভুল চেষ্টা (চতুর্থবারে "locked"). Loop coverage: ০, ১, ২, আর সীমার চারপাশে ৩ ও ৪টি চেষ্টা; ৩টি ভুল চেষ্টা হলে "failed", ৪টি হলে "locked". সাথে MC/DC: সঠিক অঙ্ক কিন্তু দৈর্ঘ্য ভুল, যেমন expected নিজেই ৫ অঙ্কের হলে।

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

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

ক্রমCoverage মাপকাঠিগুলো দুর্বল থেকে কড়া ক্রমে সাজান (▲▼ চেপে সরান)

  1. Statement coverage
  2. Branch (decision) coverage
  3. Condition/decision coverage
  4. MC/DC
  5. Multiple-condition coverage

কোড: discount = 0; if total > 1000: discount = total // 10; return discount. একটিমাত্র test, total = 1500. Statement আর branch coverage কত?

  • ১০০% আর ১০০%
  • ১০০% আর ৫০%
  • ৬৭% আর ৫০%
  • ৫০% আর ১০০%

Decision A and B and C and D (চারটি স্বাধীন condition)-এ unique-cause MC/DC-র ন্যূনতম test কয়টি?

  • ২
  • ৪
  • ৫
  • ১৬

if A and B-এর জন্য দুটি test: (A=T, B=F) আর (A=F, B=T). কোন কথাটি সত্য?

  • Condition coverage পূরণ, কিন্তু decision coverage নয়
  • Decision coverage পূরণ, কিন্তু condition coverage নয়
  • MC/DC পূরণ
  • কোনো শর্তের স্তরের coverage পূরণ হয়নি

একটি function-এর control-flow graph-এ ৯টি node আর ১১টি edge (এক entry, এক exit). Cyclomatic complexity কত?

  • ২
  • ৩
  • ২০
  • ৪

coverage.py --branch রিপোর্টের Missing কলামে 7->9 লেখা। এর অর্থ কী?

  • লাইন ৭, ৮ আর ৯ কোনো test-এ চলেনি
  • লাইন ৭-এর decision থেকে লাইন ৯-এ যাওয়ার শাখা কখনো নেওয়া হয়নি
  • লাইন ৭ থেকে ৯-এর test fail করেছে
  • লাইন ৭ থেকে ৯-এর পথ অসম্ভব, তাই বাদ দেওয়া হয়েছে

Coupon-এর নিয়ম “১০০০ টাকার বেশি হলে ছাড়”। কোডে ভুল করে >= লেখা, আর test 500 ও 1500 দিয়ে branch coverage ১০০%. সব test পাস। এটি কী দেখায়?

  • coverage.py ভুল হিসাব করেছে
  • ১০০% branch coverage থাকলে আর test-এর দরকার নেই
  • Coverage চলা মাপে; ভুলটি ধরতে সীমার মান 1000-এর test লাগবে
  • MC/DC চালালে নিশ্চিতভাবে ধরা পড়ত

শব্দকোষ

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

মনে রাখুন

  1. White-box কৌশল কোডের গঠন থেকে coverage item বানায়; মাপ = ছোঁয়া item ÷ মোট item.
  2. Branch statement-কে subsume করে; else-হীন if-এ দুটির পার্থক্য দেখা যায়। Condition coverage branch নিশ্চিত করে না।
  3. MC/DC: প্রতিটি condition-এর একটি independence pair; (A and B) or C-এ ৪টি test, সব সমন্বয়ে ৮টি।
  4. V(G) = E − N + 2 = decision + 1; loop-এ পথ বিস্ফোরিত হয়, তাই basis path আর loop coverage (০, ১, ২, অনেক, সীমা)।
  5. coverage run --branch + coverage report -m: Missing-এ লাইন আর তীর পড়ুন। ১০০% coverage ভুল মান, না-লেখা কোড বা দুর্বল assertion ধরে না; সীমার মান আর requirement-ভিত্তিক expected লাগে।

পরের পর্বে: নিয়ম আর কোড দুটোই দেখা হলো। এবার অভিজ্ঞতার পালা: error guessing, checklist আর exploratory testing, যেখানে বাংলা লেখা, ফোন নম্বরের রূপ আর টাকার গোলমাল নিজে খুঁজবেন।

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

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