এই পর্বে যা শিখবেন
- কোড থেকে 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-এর তালিকা দেয়, আর মাপ সবসময় একই সূত্রে:
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
- Function-এর executable লাইনগুলো নম্বর দিন (ঘোষণা আর docstring বাদ)।
- পরপর চলা লাইন যেখানে কোনো শাখা বা লাফ নেই, সেগুলো এক node-এ রাখুন।
- প্রতিটি শর্তকে decision node বানান, T আর F দিকের তীর আঁকুন।
- যেখানে পথ আবার মেলে (if-এর শেষে, loop-এর মাথায়, exit-এ), সেখানে তীর মেলান। Loop-এর শেষ থেকে মাথায় ফেরার তীর হলো back edge.
- 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
- Node ১ — জেলার শর্ত। লাইন ২-এর
iffunction-এর প্রথম executable লাইন, তাই এটিই entry. এখান থেকে দুটি তীর বের হবে, তাই এটি decision node (কমলা)। - Node ২ — টাকার শর্ত। জেলা ঢাকা হলে (T) নিয়ন্ত্রণ যায় লাইন ৩-এ,
total >= 2000. এটিও decision, সবুজ T তীর ১ → ২. - Node ৩ আর ৪ — ঢাকার দুই ফল। T দিকে লাইন ৪ (
return 0), F দিকে লাইন ৫ (return 60). দুটিই সাধারণ block (নীল)। - Node ৫ — সদস্যের শর্ত। জেলা ঢাকা না হলে (F) নিয়ন্ত্রণ সোজা লাইন ৬-এ,
if member. তৃতীয় decision. - Node ৬ আর ৭ — বাইরের দুই ফল। সদস্য হলে লাইন ৭ (
return 60), না হলে লাইন ৮ (return 120). - 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 সহজেই লিখতেন: ঢাকায় বড় অর্ডার আর বাইরে ছোট অর্ডার।
| test | |
| চলা লাইন | |
| নেওয়া branch | |
| statement | |
| branch |
- শুরু। CFG থেকে item তালিকা: statement লাইন ২ থেকে ৮, সাতটি; branch ছয়টি: 2→3, 2→6, 3→4, 3→5, 6→7, 6→8. প্রতিটি তীরের প্রথম সংখ্যা decision-এর লাইন, দ্বিতীয়টি যে লাইনে যায়।
- Test ১: ঢাকা, ২৫০০ টাকা। লাইন ২ সত্য, লাইন ৩ সত্য, লাইন ৪-এ ফ্রি। চলল তিনটি লাইন, নেওয়া হলো দুটি তীর। Statement ৩/৭ = ৪২.৯%, branch ২/৬ = ৩৩.৩%.
- Test ২: রাজশাহী, ৫০০ টাকা। লাইন ২ মিথ্যা, তাই 2→6; সদস্য নন, তাই 6→8, ১২০ টাকা। নতুন দুটি লাইন আর দুটি তীর। মোট statement ৫/৭ = ৭১.৪%, branch ৪/৬ = ৬৬.৭%.
- ফাঁক পড়া। না-চলা লাইন ৫ আর ৭: “ঢাকায় ছোট অর্ডার” আর “বাইরের Plus সদস্য”। দুটি নিয়মই requirement-এ আছে, অথচ কোনো test সেগুলো চালায়নি। White-box মাপ এখানে আসল কাজটি করল: নির্দিষ্ট করে দেখাল কোন আচরণ যাচাই হয়নি।
- দুটি 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 বেড়েছে, অথচ একটি ফলও যাচাই হয়নি; §৮-এ এই ফাঁদে ফিরব।
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 বাছাই
- Decision-এর truth table লিখুন: n condition-এ 2ⁿ সারি, প্রতিটির ফল।
- প্রতিটি condition-এর জন্য সব independence pair খুঁজুন: এক condition বদলালে ফল বদলায় এমন সারির জোড়া।
- যে condition-এর জোড়া মাত্র একটি, সেই জোড়ার দুই সারি বাধ্যতামূলক; আগে সেগুলো নিন।
- বাকি condition-এর জন্য এমন জোড়া বাছুন, যার একটি সারি আগেই নেওয়া আছে; এতে নতুন test মাত্র একটি লাগে।
- শেষে যাচাই: প্রতিটি condition-এর জোড়া set-এর ভেতরেই আছে কি না। সাধারণ গঠনে n + 1টি test যথেষ্ট হয়; কিছু গঠনে বেশি লাগে, তবে প্রতিটি condition-এর জোড়া থাকলে 2n-এর বেশি লাগে না।
| ধাপ | |
| দেখা যাচ্ছে | |
| test সংখ্যা |
- Truth table. তিন condition-এ ৮টি সারি।
A and Bসত্য হলে, অথবা C সত্য হলে ফল সত্য। ৮টির মধ্যে ৫টিতে ফ্রি delivery. - A-র জোড়া। A বদলালে ফল বদলায় শুধু তখন, যখন B সত্য আর C মিথ্যা: FTF (ফল F) আর TTF (ফল T). C সত্য হলে
orএমনিতেই সত্য, আর B মিথ্যা হলেandএমনিতেই মিথ্যা; এভাবে একটি condition অন্যটির প্রভাব ঢেকে দেওয়াকে বলে masking. - B-র জোড়া। একইভাবে একটিই: TFF আর TTF. A-র জোড়ার সাথে TTF সারিটি ভাগাভাগি হচ্ছে, তাই তিনটি সারিতেই A আর B দুটোর প্রমাণ।
- C-র জোড়া।
A and Bমিথ্যা থাকলে C-ই ফল ঠিক করে, তাই তিনটি জোড়া। আগে নেওয়া FTF বা TFF-এর সাথী আছে (FTT, TFT), তাই নতুন test মাত্র একটি লাগবে। - Set বাছাই। TTF, FTF, TFF বাধ্যতামূলক; C-র জন্য TFT যোগ করলে জোড়া TFF ↔ TFT. মোট ৪ = n + 1. ন্যূনতম set ঠিক দুটি: {TTF, FTF, TFF, TFT} আর {TTF, FTF, TFF, FTT}; scratch script-এ সব ৮টি সারির সব উপসেট খুঁজে মেলানো হয়েছে।
- তুলনা। 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
(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 | জেলা, মোট, promo | A B C | Expected | Coverage item |
|---|---|---|---|---|
| FD-1 | Dhaka, 2500, False | T T F | ফ্রি (True) | A, B-র জোড়ার সাধারণ সারি |
| FD-2 | Khulna, 2500, False | F T F | ফ্রি নয় (False) | A-র জোড়া (FD-1-এর সাথে) |
| FD-3 | Dhaka, 1500, False | T F F | ফ্রি নয় (False) | B-র জোড়া (FD-1), C-র জোড়া (FD-4) |
| FD-4 | Dhaka, 1500, True | T 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-এ তিনটিই এক:
এক 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-এ ভেতরেরটি থেকে শুরু করুন, বাইরেরগুলো ন্যূনতমে রেখে।
| ID | items | ঘূর্ণন | Expected | কী ধরে |
|---|---|---|---|---|
| CT-1 | [] | ০ | 0 | শুরুর মান ভুল (যেমন None) |
| CT-2 | [(100, 2)] | ১ | 200 | গুণের ভুল |
| CT-3 | [(100, 0), (80, 3)] | ২ | 240 | continue-এর পরে 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 totalfrom 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)]) == 250pyproject.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 রিপোর্ট হাতে পেলে — পাঁচ ধাপের অভ্যাস
- লাল আর হলুদ আগে, শতাংশ পরে। প্রতিটি না-চলা লাইন বা তীরের পাশে লিখুন সেটি কোন requirement-এর কোন আচরণ।
- শ্রেণিভাগ করুন। (ক) যাচাই হওয়া দরকার কিন্তু হয়নি; (খ) প্রায় অসম্ভব পথ, যেমন রক্ষণাত্মক
raise; (গ) মৃত কোড, যা মুছে ফেলা উচিত। শুধু (ক)-এর জন্য test লিখুন, (গ) developer-কে জানান। - Test নকশা black-box কৌশলে। না-চলা শাখার শর্ত থেকে partition আর সীমা বের করুন (পর্ব ০৭, ০৮), যুক্ত শর্ত হলে MC/DC জোড়া।
- Expected মান requirement থেকে। কোড পড়ে expected লিখলে ভুল কোডকেই সঠিক বলে লিখে ফেলবেন।
- ভুল বসিয়ে যাচাই। নতুন 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 চাইতে পারেন, কোড-ভিত্তিক নয়:
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-এ মেলানো।
-
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 আলাদা করে যোগ করুন (১০,০০০ আর ১০,০০১)।
-
রিপোর্ট পড়ুন (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, 19Coupon-এর দুই দিক আর cart-এর
continueএখন চলেছে। না-চলা লাইন ১৭ আর ১৯; partial branch দুটি (লাইন ১৫ আর ১৮), যাদের না-নেওয়া দিক ঠিক ওই missing লাইনেই যায়, তাই আলাদা তীর লেখা নেই। Cover = (১৮ + ১০) ÷ ৩২ = ৮৭.৫%, রিপোর্টে গোল করে ৮৮%. যোগ করুন:delivery_charge("Dhaka", 1500) == 60আরdelivery_charge("Sylhet", 500, member=True) == 60. -
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 NoneCoverage দাবি সত্য: খালি 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 চালানো মাপে, যাচাই নয়। -
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 মাপকাঠিগুলো দুর্বল থেকে কড়া ক্রমে সাজান (▲▼ চেপে সরান)
- Statement coverage
- Branch (decision) coverage
- Condition/decision coverage
- MC/DC
- 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 চালালে নিশ্চিতভাবে ধরা পড়ত
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- White-box কৌশল কোডের গঠন থেকে coverage item বানায়; মাপ = ছোঁয়া item ÷ মোট item.
- Branch statement-কে subsume করে; else-হীন
if-এ দুটির পার্থক্য দেখা যায়। Condition coverage branch নিশ্চিত করে না। - MC/DC: প্রতিটি condition-এর একটি independence pair;
(A and B) or C-এ ৪টি test, সব সমন্বয়ে ৮টি। - V(G) = E − N + 2 = decision + 1; loop-এ পথ বিস্ফোরিত হয়, তাই basis path আর loop coverage (০, ১, ২, অনেক, সীমা)।
coverage run --branch+coverage report -m: Missing-এ লাইন আর তীর পড়ুন। ১০০% coverage ভুল মান, না-লেখা কোড বা দুর্বল assertion ধরে না; সীমার মান আর requirement-ভিত্তিক expected লাগে।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ১৪ · অভিজ্ঞতাভিত্তিক testing — error guessing, checklist আর exploratoryপরবর্তী পর্বনিয়মের বাইরের ভুল খোঁজার কৌশল।
- সফটওয়্যার টেস্টিং ও QA · কোর্স হোম৮২টি পর্বপুরো কোর্সের রোডম্যাপ।
- পর্ব ০৮ · Boundary value analysisজুটি কৌশলযে মান coverage ধরে না, সেই সীমার মান।
- সফটওয়্যার ইঞ্জিনিয়ারিং ও Git · পর্ব ৫০পাশের ট্র্যাকCoverage, cognitive complexity আর mutation testing-এর পরিচয়।
- বিচ্ছিন্ন গণিত · পর্ব ৫৭গণিতGraph-এর মৌলিক ধারণা, যার ওপর CFG দাঁড়িয়ে।