এই পর্বে যা পাবেন
- Partition গোনা, প্রতিনিধি বাছা, each-choice আর base-choice-এর test সংখ্যা, partition coverage
- ISTQB-আক্ষরিক রীতিতে ২-মান আর ৩-মান boundary, লুকানো সীমা, code point আর সময় অঞ্চলের সীমা
- Decision table ভরা আর ছোট করা, rule-count দিয়ে যাচাই, requirement-এর বিরোধ খোঁজা
- State table, 0-switch আর 1-switch coverage, pairwise আর orthogonal array, classification tree
- Use case-এর scenario গোনা, constraint-সহ test গোনা
- Statement, branch, MC/DC, cyclomatic complexity, path, def-use pair আর mutation score-এর হিসাব
১ · পাতার নিয়ম, বাজারঘরের স্থির নিয়ম আর খাতার কৌশল
মডিউল ১৪-এ স্বাগতম। রান্নার রেসিপি মুখস্থ থাকলেই রান্না হয় না; হাঁড়িতে চাল মেপে, লবণ চেখে তবে হাত পাকে। Test design-ও তাই: কৌশলের নাম জানা আর একটি নিয়ম থেকে ঠিক কয়টি test, কোন কোন মান, তা বের করতে পারা আলাদা জিনিস। বিশ্ববিদ্যালয়ের Software Testing বা Software Quality কোর্সে, চাকরির লিখিত পরীক্ষায়, ISTQB-এর syllabus ধরে প্রস্তুতিতে আর কাজের প্রথম দিনে এই হিসাবগুলোই বারবার আসে। মডিউলের পরের পর্বগুলো অন্য দিক দেখবে: পর্ব ৭৯ “MCQ প্রশ্নব্যাংক”, পর্ব ৮০ “লিখিত ও মৌখিক (ভাইভা) প্রশ্ন”, পর্ব ৮১ “Manual QA ইন্টারভিউ” আর পর্ব ৮২ “Automation আর SDET ইন্টারভিউ”. পুরো strategy একসাথে দেখতে চাইলে পর্ব ৭৭ “ক্যাপস্টোন”.
বাজারঘরের নিয়ম — পুরো পাতায় একই
| নিয়ম | বিবরণ |
|---|---|
| Coupon | পণ্যের মোট (পূর্ণ টাকা) ১০০০-এর বেশি হলে ১০% ছাড়, ভগ্নাংশ বাদ (floor), সর্বোচ্চ ৩০০; শুধু পণ্যের দামে। মোট ১-এর কম হলে error. 1000 → 0, 1001 → 100, 2999 → 299, 3000 → 300 |
| Delivery | ঢাকায় ৬০, পণ্যের মোট (ছাড়ের আগে) ২০০০ বা বেশি হলে ফ্রি; ঢাকার বাইরে ১২০, Plus সদস্যের ৬০ (ঢাকায় সাধারণ নিয়ম)। Gazipur আর Narayanganj ঢাকার বাইরে |
| Phone | দুই প্রান্তের ফাঁকা ছাঁটার পরে ঠিক ১১টি ASCII অঙ্ক, শুরু 01, তৃতীয় অঙ্ক 3–9 (কাল্পনিক নিয়ম)। বাংলা অঙ্ক validator নেয় না |
| Order | placed → paid → packed → shipped → delivered; cancel শুধু placed, paid, packed থেকে; refund শুধু cancelled থেকে, আর টাকা দেওয়া থাকলে |
| Review | AC1 শুধু delivered অর্ডারের পণ্য; AC2 তারা ১–৫ পূর্ণসংখ্যা; AC3 লেখা ছাঁটার পরে ১০–৫০০ Unicode code point; AC4 প্রতি ক্রেতা প্রতি পণ্যে একটি; AC5 গড় এক দশমিকে, half up (4.25 → 4.3) |
| Cart | এক লাইনে ১–১০টি, আর কখনো stock-এর বেশি নয় |
গোনার রীতি — প্রশ্নে অন্য কিছু না বললে
| বিষয় | রীতি | ঝালিয়ে নিন |
|---|---|---|
| Boundary | ISTQB-আক্ষরিক: অবৈধ partition-এর কিনারাও সীমা; ক্ষুদ্রতম ধাপ ১ টাকা বা ১ অক্ষর | পর্ব ০৮ |
| Partition test | প্রতিটি invalid partition আলাদা test-এ, বাকি ঘর বৈধ | পর্ব ০৭ |
| Decision table | Y/N শর্ত; coverage-এর হরে শুধু সম্ভব কলাম | পর্ব ০৯ |
| State | প্রতিটি অবৈধ event আলাদা test-এ; guard-এ অসম্ভব জোড়া বাদ | পর্ব ১০ |
| Coverage | Statement = def লাইন বাদে executable লাইন; branch = decision-এর T আর F তীর | পর্ব ১৩ |
| Mutation score | killed ÷ (মোট − equivalent) × ১০০ | পর্ব ৫৯ |
১. নিয়মটি নিজের ভাষায় এক লাইনে। “বেশি” না “বা বেশি”, ছাড়ের আগে না পরে: এই এক শব্দেই উত্তর বদলায়।
২. রীতি ঘোষণা করুন। “ISTQB-আক্ষরিক ৩-মান BVA” বা “শুধু বৈধ কিনারা”; পরীক্ষক যে রীতিই চান, আপনার উত্তর যেন যাচাই করা যায়।
৩. Coverage item আগে, test পরে। Partition, সীমা, কলাম, transition, জোড়া: আগে তালিকা ও সংখ্যা, তারপর test.
৪. Expected আসে নিয়ম থেকে। কোড চালিয়ে expected লিখলে ভুল কোডের test-ও সবুজ হয়।
৫. ভাগফল লিখুন, শতাংশ পরে। “৩/৫ = ৬০%” লিখলে হর ভুল হলে পরীক্ষক ধরতে পারেন, আপনিও।
২ · Equivalence partitioning — দল গোনা, প্রতিনিধি আর coverage
Partition একে অপরের সঙ্গে মেশে না, আর মিলে পুরো input-জগৎ ঢাকে। Each-choice-এ valid test = সবচেয়ে বেশি valid দলের সংখ্যা, invalid test = সব invalid দলের যোগফল। Base-choice = ১ + ∑(দল − ১). Partition coverage = ছোঁয়া দল ÷ মোট দল × ১০০. দুটি invalid একসাথে দিলে একটি অন্যটিকে ঢাকে: error masking.
২.১(সহজ) Coupon-এর নিয়ম: পূর্ণ টাকার মোট ১০০০-এর বেশি হলে ১০% ছাড় (floor), সর্বোচ্চ ৩০০; মোট ১-এর কম বা ভগ্নাংশ হলে error. (ক) সব partition আর প্রতিটির একটি প্রতিনিধি ও expected লিখুন। (খ) সর্বনিম্ন কয়টি test? (গ) একটি suite চালায় 500, 2000 আর −50: partition coverage কত? (ঝালিয়ে নিন: পর্ব ০৭)
(a) X1 total <= 0 -50 -> error
V1 1..1000 500 -> 0
V2 1001..3000 2000 -> 200
V3 3001 and above 5000 -> 300 (cap)
X2 not a whole number 1500.5 -> error
(b) 5 tests: one per partition, each invalid one alone
(c) touched X1, V1, V2 -> 3/5 = 60%
V2 আর V3 আলাদা দল, কারণ আচরণ আলাদা: V3-এ cap কাজ করে। পর্ব ০৭-এর চালানো test-এ cap-এর ভুল ধরা পড়েছিল শুধু V3-এর প্রতিনিধি 5000-এ (AssertionError: 500 != 300); V1 বা V2-এর মান সেই ভুল কখনো দেখত না।
২.২(সহজ) Phone-এর শর্ত, ফাঁকা ছাঁটার পরে: C1 দৈর্ঘ্য ঠিক ১১, C2 সব অক্ষর ASCII অঙ্ক, C3 শুরু 01, C4 তৃতীয় অঙ্ক 3–9. প্রতিটি input কোন শর্ত ভাঙে বলুন, আর কোনগুলো “একটিমাত্র শর্ত ভাঙা” প্রতিনিধি হিসেবে চলে: " 01912345678 ", 01212345678, 0171234567, 01712 345678, ০১৭১২৩৪৫৬৭৮, +8801712345678. (ঝালিয়ে নিন: পর্ব ০৭, ১৪)
" 01912345678 " valid (spaces trimmed, 3rd digit 9)
01212345678 C4 only -> clean representative (3rd digit 0-2)
0171234567 C1 only -> clean representative (10 digits)
01712 345678 C1 + C2 -> masking: which rule rejected it?
০১৭১২৩৪৫৬৭৮ C2 + C3 + C4 -> Bangla digits, not ASCII
+8801712345678 C1 + C2 + C3 -> 14 characters with '+'
শুধু দ্বিতীয় আর তৃতীয়টি পরিষ্কার প্রতিনিধি। বাংলা অঙ্ক আর +880 বাস্তবে খুব আসে, তাই এগুলো error guessing-এর দামি input; কিন্তু partition-এর প্রতিনিধি হিসেবে নয়, কারণ একসাথে কয়েকটি শর্ত ভাঙে। বাংলা অঙ্ক রূপান্তরের কাজ form-এর আলাদা ধাপের, validator-এর নয়।
২.৩(মাঝারি) অর্ডার-ফর্মে তিনটি ঘর: পরিমাণ (১–১০ পূর্ণসংখ্যা valid; invalid: ০ বা কম, ১০-এর বেশি, ভগ্নাংশ), payment (cash, mobile-wallet, card; invalid: কিছু বাছাই হয়নি), slot (সকাল, দুপুর, সন্ধ্যা; invalid: বাছাই হয়নি)। (ক) মোট দল? (খ) Each-choice আর একবারে একটি invalid নিয়মে সর্বনিম্ন test? (গ) Base-choice-এ? (ঘ) শুধু valid মিশ্রণ আর সব দলের সব মিশ্রণ? (ঙ) তিনটি test (৫, cash, সকাল), (৭, card, সন্ধ্যা), (০, cash, সকাল)-এর coverage? (ঝালিয়ে নিন: পর্ব ০৭)
quantity 1 valid + 3 invalid = 4 ; payment 3 + 1 = 4 ; slot 3 + 1 = 4
(a) 4 + 4 + 4 = 12
(b) valid tests = max(1, 3, 3) = 3 ; invalid = 3 + 1 + 1 = 5 -> 8
(c) 1 + (4-1) + (4-1) + (4-1) = 10
(d) valid 1 x 3 x 3 = 9 ; all 4 x 4 x 4 = 64
(e) qty ok, qty <= 0, cash, card, morning, evening -> 6/12 = 50%
(ঙ)-তে test তিনটি, কিন্তু coverage গোনা হয় দল দিয়ে। Mobile-wallet, দুপুর, দুটি invalid পরিমাণ-দল আর দুটি “বাছাই হয়নি” দল বাকি।
২.৪(মাঝারি) রিভিউ ফর্ম, শুধু তিনটি শর্ত ধরে: AC1 অর্ডার delivered; AC2 তারা ১–৫ পূর্ণসংখ্যা (JSON-এ "5", 4.5, true প্রত্যাখ্যাত); AC3 লেখা ছাঁটার পরে ১০–৫০০ code point. প্রতিটি ঘরের valid আর invalid দল লিখুন, মোট দল আর “একবারে একটি invalid” নিয়মে সর্বনিম্ন test গুনুন। (ঝালিয়ে নিন: পর্ব ১৫, ০৭)
stars : V 1..5 | X missing, <= 0, >= 6, fraction (4.5), not a number ("5", true)
text : V 10..500 | X empty or spaces only, 1..9, 501+
order : V delivered | X not delivered
partitions 6 + 4 + 2 = 12
tests = 1 all-valid + 5 + 3 + 1 = 10
true আলাদা করে মনে রাখুন: Python-এ True একটি int, তাই ভুল কোড এটিকে ১ তারা হিসেবে মেনে নিতে পারে (৮.২-এ ঠিক এই ভুলটি দেখবেন)। শুধু ফাঁকা দিয়ে লেখা দশ অক্ষর ছাঁটার পরে শূন্য: লুকানো দল।
def coupon_part(v): # 2.1: five partitions
if v != int(v): return "X2"
if v <= 0: return "X1"
return "V1" if v <= 1000 else "V2" if v <= 3000 else "V3"
hit = {coupon_part(v) for v in (500, 2000, -50)}
print("2.1 touched:", sorted(hit), f"-> {len(hit)}/5 = {100*len(hit)/5:.0f}%")
def broken(raw): # 2.2: which phone rules break?
s, out = raw.strip(), []
if len(s) != 11: out.append("C1")
if any(c not in "0123456789" for c in s): out.append("C2")
if not s.startswith("01"): out.append("C3")
if len(s) < 3 or s[2] not in "3456789": out.append("C4")
return out or ["valid"]
for raw in [" 01912345678 ", "01212345678", "0171234567",
"01712 345678", "০১৭১২৩৪৫৬৭৮", "+8801712345678"]:
print("2.2", repr(raw).ljust(17), broken(raw))
def qty_part(q): # 2.3: 1 valid + 3 invalid
return "q:frac" if q != int(q) else "q:<=0" if q < 1 else "q:>10" if q > 10 else "q:ok"
F = [(1, 3), (3, 1), (3, 1)] # (valid, invalid) per field
parts = sum(v + x for v, x in F)
each = max(v for v, x in F) + sum(x for v, x in F)
base = 1 + sum(v + x - 1 for v, x in F)
print("2.3 parts", parts, "| each-choice", each, "| base-choice", base,
"| valid combos", 1 * 3 * 3, "| all combos", 4 * 4 * 4)
tests = [(5, "cash", "morning"), (7, "card", "evening"), (0, "cash", "morning")]
seen = {qty_part(q) for q, p, s in tests} | {p for q, p, s in tests} | {s for q, p, s in tests}
print("2.3 coverage:", f"{len(seen)}/{parts} = {100*len(seen)/parts:.1f}%")
R = [(1, 5), (1, 3), (1, 1)] # 2.4 stars, text, order status
print("2.4 partitions", sum(v + x for v, x in R), "| tests", 1 + sum(x for v, x in R))প্রথম লাইন: ছোঁয়া দল ['V1', 'V2', 'X1'], অর্থাৎ 3/5 = 60%. Phone-এর ছয়টি input-এর পাশে ভাঙা শর্তের তালিকা: ফাঁকাসহ নম্বরটি ['valid'], দুটি পরিষ্কার প্রতিনিধি ['C4'] আর ['C1'], বাংলা অঙ্কের নম্বর ['C2', 'C3', 'C4']. ফর্মের হিসাব parts 12 | each-choice 8 | base-choice 10 | valid combos 9 | all combos 64, coverage 6/12 = 50.0%, আর রিভিউর partitions 12 | tests 10. সব সংখ্যা ২.১–২.৪-এর উত্তরের সাথে মেলে।
৩ · Boundary value analysis — ২-মান, ৩-মান আর লুকানো সীমা
ঝালিয়ে নিন: পর্ব ০৮ · Boundary value analysis, পর্ব ৫৮ · Property-based testing. সংক্ষিপ্ত পরিচয়: সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৪৭.
সীমার মান = প্রতিটি partition-এর সর্বনিম্ন আর সর্বোচ্চ (খোলা দিক বাদ)। ২-মান: সীমা আর পাশের দলের নিকটতম মান; দল গায়ে গায়ে লাগানো হলে set = সীমার তালিকা। ৩-মান: প্রতিটি সীমা আর তার দুই প্রতিবেশী, পুনরাবৃত্তি বাদে। Jorgensen-এর রূপ, n input: normal 4n + 1, robustness 6n + 1, worst-case 5n, robust worst-case 7n.
৩.১(সহজ) Coupon: মোট পূর্ণ টাকা, ১০০০-এর বেশি হলে ১০% (floor), সর্বোচ্চ ৩০০; মোট ১-এর কম হলে error. সীমার মান, ২-মান set আর ৩-মান set লিখুন, প্রতিটি মানের expected-সহ। শুধু বৈধ দলের কিনারা ধরার রীতিতে ৩-মান set-এ কয়টি? (ঝালিয়ে নিন: পর্ব ০৮)
partitions <=0 | 1..1000 | 1001..3000 | 3001+
boundaries 0, 1, 1000, 1001, 3000, 3001 -> 6
2-value the same 6 (partitions touch)
3-value -1 0 1 2 999 1000 1001 1002 2999 3000 3001 3002 -> 12
expected err err 0 0 0 0 100 100 299 300 300 300
valid edges only: drop -1 -> 11
নিচের stepper একই হিসাব ধাপে ধাপে দেখায়। পরীক্ষায় রীতি বলা না থাকলে উত্তরের শুরুতেই লিখুন কোন রীতিতে গুনছেন।
step = 1 taka <=0 │ 1..1000 │ 1001..3000 │ 3001+ err │ 0 │ 10% │ 300
min/max of each partition 0 │ 1..1000 │ 1001..3000 │ 3001 6 boundaries
1000 + nearest other = 1001
1001 already listed
2-value = 6 values
+ -1, 2, 999, 1002,
2999, 3002
3-value = 12 values
3000 -> 300 3009 -> 300
cap matters first at 3010
(no BVA value reaches it)
- দল। ক্ষুদ্রতম ধাপ ১ টাকা। “বেশি” শব্দের জন্য ১০০০ ছাড়হীন দলে; চারটি ক্রমযুক্ত দল।
- সীমা। প্রতিটি দলের সর্বনিম্ন আর সর্বোচ্চ; অবৈধ দলের সর্বোচ্চ 0-ও গোনা হয়। খোলা দুই প্রান্তে সীমা নেই: মোট ৬টি।
- ২-মান। 1000-এর পাশের দলের নিকটতম মান 1001, যা আগেই আছে। দল গায়ে গায়ে লাগানো, তাই কিছুই যোগ হয় না।
- ৩-মান। প্রতিটি সীমার দুই প্রতিবেশী; ছয়টি নতুন মান যোগ হয়ে ১২টি।
- লুকানো সীমা। Floor-এর জন্য 3000 থেকে 3009 পর্যন্ত cap থাকুক বা না থাকুক ফল 300; cap-এর প্রভাব প্রথম 3010-এ, যা কোনো BVA set-এ নেই।
৩.২(মাঝারি) রিভিউ: লেখা ছাঁটার পরে ১০–৫০০ Unicode code point, তারা ১–৫ পূর্ণসংখ্যা। (ক) লেখার দৈর্ঘ্যের সীমা, ২-মান আর ৩-মান set (দৈর্ঘ্য ঋণাত্মক হয় না)। (খ) তারার একই হিসাব। (গ) এই লেখাগুলোর দৈর্ঘ্য কত, গ্রহণ না প্রত্যাখ্যান: ভালো চাল, " ভালো লেগেছে ", দারুণ👍. (ঘ) একটি JavaScript validator text.trim().length দিয়ে গোনে; 000000𐀀𐀀 লেখাটি সে কী করবে? (ঝালিয়ে নিন: পর্ব ০৮, ৫৮)
(a) partitions 0..9 | 10..500 | 501+ ; boundaries 0, 9, 10, 500, 501 -> 5
2-value = 5 ; 3-value 0 1 8 9 10 11 499 500 501 502 -> 10
(b) partitions <=0 | 1..5 | 6+ ; 2-value 0 1 5 6 -> 4
3-value -1 0 1 2 4 5 6 7 -> 8
(c) "ভালো চাল" 8 code points -> reject
"ভালো লেগেছে" 11 after trim -> accept
"দারুণ👍" 6 code points -> reject (UTF-16: 7)
(d) 8 code points but 10 UTF-16 units -> the JS check wrongly accepts
চোখে “ভালো চাল” দুটি শব্দ, অথচ code point ৮টি: কার, হসন্ত আর ফাঁকাও গোনা হয়। (ঘ)-র লেখাটি বানানো নয়; পর্ব ৫৮-এ Hypothesis রিভিউর UTF-16 ভুলকে ঠিক এই '000000𐀀𐀀'-এ নামিয়ে এনেছিল। 𐀀 একটি code point, কিন্তু UTF-16-এ দুটি একক।
৩.৩(মাঝারি) ঢাকায় ফ্রি delivery-র সঠিক শর্ত total >= 2000. চারটি mutant: > 2000, >= 1999, >= 2001, == 2000. শুধু ২০০০-এর সীমা ধরে ২-মান set {1999, 2000} আর ৩-মান set {1998, 1999, 2000, 2001} কোন mutant মারে? (ঝালিয়ে নিন: পর্ব ০৮)
mutant 2-value kills 3-value kills
> 2000 2000 2000
>= 1999 1999 1999
>= 2001 2000 2000
== 2000 - (survives) 2001
score 3/4 4/4
== mutant 1999-এ মিথ্যা আর 2000-এ সত্য দেয়, ঠিক আসল কোডের মতো; পার্থক্য শুধু 2001 থেকে ওপরে। সীমার ভেতরের প্রতিবেশীই এই ভুল ধরে, আর এ জন্যই ঝুঁকিপূর্ণ সীমায় ৩-মান।
৩.৪(মাঝারি) (ক) Coupon-এ (১০০০-এর বেশি হলে ১০%, floor, সর্বোচ্চ ৩০০) কোন মোটে cap প্রথম ফল বদলায়? Cap ভুল করে ৩০১ লেখা mutant কোন মান মারে, আর coupon-এর ২-মান বা ৩-মান set কি মারে? (খ) একটি coupon চলবে “৩১ ডিসেম্বর ২০২৬, রাত ১১:৫৯:৫৯ পর্যন্ত, ঢাকার সময়ে (UTC+6)”; server সময় রাখে UTC-তে। সময়ের সীমার দুটি test-মান UTC-তে লিখুন। (ঝালিয়ে নিন: পর্ব ০৮)
(a) floor(t/10) > 300 first at t = 3010 (3009 -> 300 either way)
cap 301 mutant: killed only by totals >= 3010
BVA sets stop at 3002 -> survive ; EP value 5000 kills it
(b) last valid 2026-12-31 17:59:59 UTC (= 23:59:59 Dhaka)
first invalid 2026-12-31 18:00:00 UTC (= 00:00:00 Dhaka, 1 Jan)
দুই ক্ষেত্রেই সীমা requirement-এর লেখা সংখ্যায় নেই: একটি এসেছে গোল করার নিয়ম থেকে, অন্যটি সময় অঞ্চল থেকে। পর্ব ০৮-এ UTC-র তারিখ তুলনা করা কোড ঠিক এই ১৮:০০:০০-তেও coupon চালু রেখেছিল।
৩.৫(কঠিন) Checkout-এ চারটি স্বাধীন ক্রমযুক্ত input: পরিমাণ (১–১০), coupon কোডের দৈর্ঘ্য (৪–১২), তারা (১–৫), লেখার দৈর্ঘ্য (১০–৫০০)। Jorgensen-এর normal BVA, robustness, worst-case আর robust worst-case-এ কয়টি test? Normal BVA-তে একটি test-এ কয়টি input সীমায় থাকে, কেন? (ঝালিয়ে নিন: পর্ব ০৮)
n = 4
normal BVA 4n + 1 = 17
robustness 6n + 1 = 25
worst-case 5^n = 625
robust worst-case 7^n = 2401
normal BVA: one input at min, min+, max-, max ; the rest at nominal
Single-fault assumption: ভুল সাধারণত একটি input-এর কারণে ঘটে, তাই একবারে একটি input সীমায় যায়। Worst-case এই অনুমান বাদ দেয়, আর গুণের নিয়মে test দ্রুত বাড়ে; সেখানে পর্ব ১১-এর pairwise বেশি কাজের।
from datetime import datetime, timedelta, timezone
def bva(parts, low=None): # ISTQB-literal, incl. invalid edges
b = sorted({v for p in parts for v in p if v is not None})
three = sorted({v + d for v in b for d in (-1, 0, 1) if low is None or v + d >= low})
return b, three # touching partitions: 2-value == b
def coupon(t):
return "err" if t < 1 else 0 if t <= 1000 else min(t // 10, 300)
for name, parts, low in [("coupon", [(None, 0), (1, 1000), (1001, 3000), (3001, None)], None),
("text", [(0, 9), (10, 500), (501, None)], 0),
("stars", [(None, 0), (1, 5), (6, None)], None)]:
b, t3 = bva(parts, low)
print(f"3 {name}: 2v {len(b)} {b}\n 3v {len(t3)} {t3}")
print("3.1", [coupon(t) for t in bva([(None, 0), (1, 1000), (1001, 3000), (3001, None)])[1]])
for s in ["ভালো চাল", " ভালো লেগেছে ", "দারুণ👍", "000000\U00010000\U00010000"]:
t = s.strip()
print("3.2", repr(t), "code points", len(t), "| UTF-16 units", len(t.encode("utf-16-le")) // 2)
good = lambda t: t >= 2000 # 3.3 free-delivery mutants
for name, m in [("> 2000", lambda t: t > 2000), (">= 1999", lambda t: t >= 1999),
(">= 2001", lambda t: t >= 2001), ("== 2000", lambda t: t == 2000)]:
kill = lambda vals: [t for t in vals if m(t) != good(t)]
print(f"3.3 {name:8} 2v kills {kill([1999, 2000])} 3v kills {kill([1998, 1999, 2000, 2001])}")
print("3.4 cap first bites at", min(t for t in range(1001, 9999) if t // 10 > 300))
print("3.5 n=4: normal", 4*4 + 1, "robust", 6*4 + 1, "worst", 5**4, "robust worst", 7**4)
BD = timezone(timedelta(hours=6))
last = datetime(2026, 12, 31, 23, 59, 59, tzinfo=BD).astimezone(timezone.utc)
print("3.4 last valid UTC:", last, "| first invalid:", last + timedelta(seconds=1))Coupon-এ 2v 6 আর 3v 12, লেখায় 2v 5 আর 3v 10 (0-এর নিচে মান নেই, তাই 0-এর প্রতিবেশী শুধু 1), তারায় 4 আর 8. পরের লাইন ৩-মান set-এর expected: ['err', 'err', 0, 0, 0, 0, 100, 100, 299, 300, 300, 300]. লেখার লাইনগুলোতে '000000𐀀𐀀' code points 8 | UTF-16 units 10: ৮ মানে প্রত্যাখ্যান, কিন্তু ১০ গুনলে গ্রহণ। Mutant-এর সারিতে শুধু == 2000-এ 2v kills [] আর 3v kills [2001]. শেষে cap first bites at 3010, Jorgensen-এর 17, 25, 625, 2401, আর সময়ের সীমা 17:59:59 বনাম 18:00:00 UTC.
৪ · Decision table আর cause-effect — কলাম গোনা, ছোট করা আর বিরোধ
ঝালিয়ে নিন: পর্ব ০৯ · Decision table আর cause-effect.
n-টি Y/N শর্তে পূর্ণ decision table-এ 2n কলাম। “−” দিয়ে মেশানো যায় যখন দুটি কলামের ফল এক আর তারা একটি শর্তে আলাদা। Rule-count: প্রতিটি rule-এ 2(− সংখ্যা); যোগফল 2n-এর বেশি হলে overlap, কম হলে ফাঁক। Coverage = চলা কলাম ÷ সম্ভব কলাম।
৪.১(সহজ) Delivery: ঢাকায় ৬০, পণ্যের মোট (ছাড়ের আগে) ২০০০ বা বেশি হলে ফ্রি; বাইরে ১২০, Plus সদস্যের ৬০. শর্ত C1 ঢাকা?, C2 মোট ≥ ২০০০?, C3 Plus? পূর্ণ টেবিল লিখুন, সবচেয়ে ছোট রূপে ছোট করুন আর rule-count দিয়ে যাচাই করুন। (ঝালিয়ে নিন: পর্ব ০৯)
column YYY YYN YNY YNN NYY NYN NNY NNN
charge 0 0 60 60 60 120 60 120
collapsed: YY- -> 0 | YN- -> 60 | N-Y -> 60 | N-N -> 120
rule count 2 + 2 + 2 + 2 = 8 = 2^3 ; expand: none missing, none wrong
N-Y আর N-N-এ C2 “−”, কারণ ঢাকার বাইরে মোট টাকা charge বদলায় না। মনে রাখবেন, “−” requirement-এর দাবি; কোডেও যে প্রভাব নেই তার নিশ্চয়তা নয়, তাই ঝুঁকি থাকলে “−”-এর দুই মানই একবার করে চালান।
YYY 0 YYN 0 YNY 60 YNN 60 NYY 60 NYN 120 NNY 60 NNN 120
YYY 0 + YYN 0 -> YY- 0 YNY 60 + YNN 60 -> YN- 60 (differ only in C3)
NYY 60 + NNY 60 -> N-Y 60 NYN 120 + NNN 120 -> N-N 120 (differ only in C2)
2 + 2 + 2 + 2 = 8
missing [] wrong []
4 rules
- পূর্ণ টেবিল। তিনটি Y/N শর্তে ৮টি কলাম, প্রতিটির charge নিয়ম থেকে হাতে হিসাব।
- ঢাকার জোড়া। ঢাকায় Plus হওয়া না হওয়ায় কিছু বদলায় না, তাই C3-এ “−”.
- বাইরের জোড়া। বাইরে মোট টাকার প্রভাব নেই, তাই C2-এ “−”; Plus আর সাধারণ আলাদা থাকে।
- যাচাই। প্রতিটি rule-এ একটি “−”, তাই ২টি করে কলাম; যোগফল ৮, খুলে মেলালে কোনো কলাম বাদ বা ভুল নেই।
৪.২(মাঝারি) রিভিউর “পোস্ট” বোতামের নিয়ম, এই ক্রমে যাচাই: অর্ডার delivered না হলে “not_delivered”; তারপর তারা ঠিক না হলে “stars”; তারপর লেখা ঠিক না হলে “text”; তারপর আগেই রিভিউ করা থাকলে “already”; সব ঠিক হলে “post”. শর্ত চারটি। (ক) পূর্ণ টেবিলে কয়টি কলাম? (খ) সবচেয়ে ছোট টেবিল আর তার rule-count. (গ) Cause-effect graph-এ “post” কোন যুক্তি-গেট? (ঝালিয়ে নিন: পর্ব ০৯)
(a) 2^4 = 16
(b) N--- not_delivered (8) | YN-- stars (4) | YYN- text (2)
YYYN already (1) | YYYY post (1) -> 8+4+2+1+1 = 16, 5 rules
(c) post = AND(delivered, stars ok, text ok, not reviewed)
পাঁচটি আলাদা ফল, তাই পাঁচটির কম rule অসম্ভব: এই টেবিলই সবচেয়ে ছোট। ক্রম বদলালে (যেমন লেখা আগে, তারা পরে) “−”-এর জায়গা বদলায়; তাই requirement-এ যাচাইয়ের ক্রম লেখা না থাকলে সেটি product owner-কে প্রশ্ন।
৪.৩(মাঝারি) Delivery-র খসড়া requirement-এ চারটি বাক্য: R1 “ঢাকায় ২০০০ বা বেশি হলে ফ্রি”, R2 “Plus সদস্যের delivery সবসময় ৬০”, R3 “ঢাকার বাইরে ১২০”, R4 “ঢাকায় ২০০০-এর কম হলে ৬০”. শর্ত C1 ঢাকা?, C2 ≥ ২০০০?, C3 Plus? প্রতিটি কলামে কোন বাক্য খাটে বলুন; কোথায় বিরোধ, কোথায় ফাঁক? (ঝালিয়ে নিন: পর্ব ০৯, ০৬)
R1 YY- (2) R2 --Y (4) R3 N-- (4) R4 YN- (2) -> 12 > 8 : overlaps
YYY R1 0, R2 60 CONTRADICTION
YNY R2 60, R4 60 overlap, same answer
NYY R2 60, R3 120 CONTRADICTION
NNY R2 60, R3 120 CONTRADICTION
other 4 columns exactly one sentence ; no gap
তিনটি বিরোধ, সবগুলো R2-এর “সবসময়” শব্দ থেকে। চূড়ান্ত নিয়মে Plus-এর সুবিধা শুধু ঢাকার বাইরে; বাক্যটি “ঢাকার বাইরে Plus সদস্যের ৬০” হলে বিরোধ মেটে। কোড লেখার আগেই এটি ধরা পড়ল, অর্থাৎ পর্ব ০৬-এর static testing.
৪.৪(কঠিন) একজন সহকর্মী ৪.১-এর delivery নিয়মের ছোট টেবিল দিলেন: YY- → 0, YN- → 60, N-- → 120. (ক) Rule-count কত, আর তাতে কি প্রমাণ হয় টেবিলটি ঠিক? (খ) কোন কলাম ভুল? (গ) এই টেবিলের প্রতিটি rule থেকে একটি test (“−”-এ N বসিয়ে) নিলে পূর্ণ টেবিলের decision table coverage কত? (ঝালিয়ে নিন: পর্ব ০৯)
(a) 2 + 2 + 4 = 8 : count matches, but that proves only "no gap, no overlap"
(b) expand N-- : NYY and NNY give 120, the rule says 60 (Plus outside Dhaka)
(c) tests YYN, YNN, NNN -> 3/8 = 37.5%
Rule-count শুধু গোনা মেলায়, উত্তর মেলায় না। টেবিলটি Plus শর্তটি পুরো ভুলে গেছে, আর সেই টেবিল থেকে বানানো test-ও কখনো C3 = Y চালায় না; তাই Plus-এর কোনো defect ধরার সুযোগই থাকে না।
from itertools import product
def delivery(dhaka, big, plus): # C1 Dhaka? C2 >= 2000 before coupon? C3 Plus?
if dhaka: return 0 if big else 60
return 60 if plus else 120
FULL = {"".join(k): delivery(*(c == "Y" for c in k)) for k in product("YN", repeat=3)}
print("4.1 full:", FULL)
expand = lambda r: ["".join(x) for x in product(*("YN" if c == "-" else c for c in r))]
def check(table, full=FULL): # rule count, missing and wrong columns
cols = {}
for rule, out in table.items():
for c in expand(rule): cols.setdefault(c, []).append(out)
return (sum(len(expand(r)) for r in table), [c for c in full if c not in cols],
[c for c in full if any(o != full[c] for o in cols.get(c, []))])
print("4.1 collapsed:", check({"YY-": 0, "YN-": 60, "N-Y": 60, "N-N": 120}))
print("4.4 colleague:", check({"YY-": 0, "YN-": 60, "N--": 120}),
"| its 3 tests YYN YNN NNN cover", f"{100 * 3 / len(FULL):.1f}%")
def button(dl, st, tx, new): # 4.2 checks in this order
return ("not_delivered" if dl == "N" else "stars" if st == "N" else
"text" if tx == "N" else "already" if new == "N" else "post")
R = {"".join(k): button(*k) for k in product("YN", repeat=4)}
small = {"N---": "not_delivered", "YN--": "stars", "YYN-": "text", "YYYN": "already", "YYYY": "post"}
print("4.2 full", len(R), "| rules", len(small), "| check", check(small, R))
DRAFT = {"R1": ("YY-", 0), "R2": ("--Y", 60), "R3": ("N--", 120), "R4": ("YN-", 60)}
for col in FULL: # 4.3 contradictions and gaps
says = {n: v for n, (r, v) in DRAFT.items() if col in expand(r)}
tag = "GAP" if not says else "CONTRADICTION" if len(set(says.values())) > 1 else "ok"
print("4.3", col, says, tag)পূর্ণ টেবিলের আটটি charge stepper-এর সাথে হুবহু এক। ছোট টেবিলের যাচাই (8, [], []): গোনা ৮, বাদ নেই, ভুল নেই। সহকর্মীর টেবিলেও গোনা 8 আর বাদ [], তবু ভুল ['NYY', 'NNY']; তাঁর তিনটি test-এর coverage 37.5%. রিভিউ বোতামে full 16 | rules 5 | check (16, [], []). শেষ আট লাইনে খসড়ার তিনটি CONTRADICTION (YYY, NYY, NNY), আর কোনো GAP নেই।
৫ · State transition — state table, 0-switch আর 1-switch
ঝালিয়ে নিন: পর্ব ১০ · State transition testing.
State table-এ ঘর = state × event; বৈধ পথ নেই এমন প্রতিটি ঘর একটি invalid transition. 0-switch = সব বৈধ transition; 1-switch জোড়া = প্রতিটি state-এ (ঢোকা তীর × বের হওয়া তীর)-এর যোগফল, তারপর guard-এ অসম্ভব জোড়া বাদ। All transitions = বৈধ আর অবৈধ সব ঘর।
৫.১(সহজ) অর্ডারের state: Placed, Paid, Packed, Shipped, Delivered, Cancelled, Refunded; event: pay, pack, ship, deliver, cancel, refund. বৈধ transition: T1 pay, T2 pack, T3 ship, T4 deliver (মূল পথ), T5–T7 Placed/Paid/Packed থেকে cancel, T8 Cancelled থেকে refund [টাকা দেওয়া থাকলে]। State table-এ কয়টি ঘর, কয়টি বৈধ, কয়টি অবৈধ? “All transitions” coverage-এ অবৈধ ঘরগুলো কীভাবে test করবেন? (ঝালিয়ে নিন: পর্ব ১০)
cells 7 x 6 = 42
valid 8 (T1..T8, each in its own cell)
invalid 42 - 8 = 34
each invalid cell: reach the state by a valid path, send ONE invalid
event, expect: rejected AND state unchanged
একটি test-এ একাধিক অবৈধ event পাঠালে একটি ভুল অন্যটিকে ঢেকে দিতে পারে: fault masking. পর্ব ১০-এর চালানো suite-এ ৩৪টি sub-test-এর ঠিক একটি লাল হয়েছিল: state='Shipped', event='cancel'.
৫.২(মাঝারি) ৫.১-এর অর্ডার-যন্ত্রে (T5 = Placed থেকে cancel, যেখানে টাকা দেওয়া হয়নি) (ক) কাঠামোগত 1-switch জোড়া কয়টি, সম্ভব কয়টি? (খ) একটি suite-এ দুটি test: “pay, pack, cancel, refund” আর “cancel”. All states, 0-switch আর 1-switch coverage কত? (ঝালিয়ে নিন: পর্ব ১০)
(a) Paid 1x2 + Packed 1x2 + Shipped 1x1 + Cancelled 3x1 = 8
T5 -> T8 impossible (guard [paid] false) -> 7 feasible
(b) test 1: T1 T2 T7 T8 ; test 2: T5
states Placed Paid Packed Cancelled Refunded = 5/7 = 71.4%
0-switch T1 T2 T5 T7 T8 = 5/8 = 62.5%
1-switch T1T2, T2T7, T7T8 = 3/7 = 42.9%
Placed-এ কোনো তীর ঢোকে না, Delivered আর Refunded থেকে কিছু বের হয় না, তাই সূত্রে তাদের অবদান শূন্য। Guard-এর জন্য বাদ পড়া জোড়ার উল্টো দিকটি (টাকা না দেওয়া অর্ডারে refund প্রত্যাখ্যাত) একটি আলাদা negative test.
পার্সেল-যন্ত্র — ৫.৩-এর state diagram
Parcel delivery state machine with a guarded second failure
৫.৩(মাঝারি) পার্সেলের কাল্পনিক নিয়ম: AtHub থেকে dispatch → OnRoute (P1); OnRoute-এ deliver → Delivered (P2); OnRoute-এ ক্রেতা অনুপস্থিত (absent): প্রথম বার → AtHub (P3), দ্বিতীয় বার → Returned (P4). Delivered আর Returned শেষ অবস্থা। (ক) State table-এ ঘর, বৈধ পথওয়ালা ঘর আর অবৈধ ঘর কয়টি? (খ) সব 1-switch জোড়া লিখুন। (গ) সবচেয়ে কম কয়টি test-এ 0-switch আর 1-switch দুটোই ১০০%? (ঝালিয়ে নিন: পর্ব ১০)
(a) 4 states x 3 events = 12 cells
cells with a path: (AtHub,dispatch) (OnRoute,deliver) (OnRoute,absent) = 3
the absent cell holds P3 and P4 (guard) ; invalid cells 12 - 3 = 9
(b) into OnRoute: P1 ; out: P2 P3 P4 -> P1P2 P1P3 P1P4
into AtHub: P3 ; out: P1 -> P3P1 = 4 pairs
(c) 2 tests (both end in a final state):
A dispatch absent dispatch deliver -> P1 P3 P1 P2 -> Delivered
B dispatch absent dispatch absent -> P1 P3 P1 P4 -> Returned
দুটি শেষ অবস্থা মানে অন্তত দুটি test, আর এখানে দুটিই যথেষ্ট। Guard-ওয়ালা ঘরে দুটি test লাগে, ঠিক অর্ডারের Cancelled–refund ঘরের মতো। নিয়মে একটি প্রশ্নও রয়ে গেল: Returned পার্সেলের টাকা কী হয়?
৫.৪(কঠিন) ৫.১-এর অর্ডার-যন্ত্রে চারটি test: “pay pack ship deliver”, “cancel”, “pay pack cancel”, “pay cancel refund”. (ক) 0-switch, 1-switch আর all transitions (৪২টি ঘর) coverage কত? (খ) Developer “Packed থেকে বাতিলে refund-এর চিহ্ন বসে না” এমন ভুল করলে কোন জোড়া সেটি ধরত? (ঝালিয়ে নিন: পর্ব ১০)
(a) 0-switch 8/8 = 100% ; states 7/7
1-switch 6/7 = 85.7%, missing T7 -> T8
all transitions 8/42 = 19.0% (no invalid cell tried)
(b) T7 -> T8: add "pay pack cancel refund"
এগারোটি event-এ ৮টি transition, তবু জোড়ার একটি বাদ। পর্ব ১০-এর চালানো উদাহরণে 0-switch suite পুরো সবুজ ছিল, আর একটি বাড়তি refund event-এর test ধরেছিল ValueError: refund not allowed in Cancelled.
T = {"T1": ("Placed", "pay", "Paid"), "T2": ("Paid", "pack", "Packed"),
"T3": ("Packed", "ship", "Shipped"), "T4": ("Shipped", "deliver", "Delivered"),
"T5": ("Placed", "cancel", "Cancelled"), "T6": ("Paid", "cancel", "Cancelled"),
"T7": ("Packed", "cancel", "Cancelled"), "T8": ("Cancelled", "refund", "Refunded")}
pairs = [(a, b) for a in T for b in T if T[a][2] == T[b][0]]
feasible = [p for p in pairs if p != ("T5", "T8")] # guard [paid]
print("5.1 cells", 7 * 6, "valid", len(T), "invalid", 7 * 6 - len(T), "| 5.2 pairs", len(pairs), "feasible", len(feasible))
def run(events): # -> states seen, transitions, pairs
st, paid, used, seen = "Placed", False, [], {"Placed"}
for e in events.split():
t = next(k for k, (s, ev, _) in T.items()
if s == st and ev == e and (k != "T8" or paid))
paid |= t == "T1"; used.append(t); st = T[t][2]; seen.add(st)
return seen, set(used), set(zip(used, used[1:]))
def coverage(name, suite):
S, U, P = set(), set(), set()
for ev in suite: s, u, p = run(ev); S |= s; U |= u; P |= p
print(f"{name}: states {len(S)}/7 0-switch {len(U)}/8 1-switch "
f"{len(P & set(feasible))}/7 missing {sorted(set(feasible) - P)}")
coverage("5.2", ["pay pack cancel refund", "cancel"])
coverage("5.4", ["pay pack ship deliver", "cancel", "pay pack cancel", "pay cancel refund"])
def parcel(events): # 5.3: the 2nd 'absent' -> Returned
fails, used = 0, []
for e in events.split():
fails += e == "absent"
used.append({"dispatch": "P1", "deliver": "P2"}.get(e, "P3" if fails < 2 else "P4"))
end = {"P1": "OnRoute", "P2": "Delivered", "P3": "AtHub", "P4": "Returned"}[used[-1]]
return used, end, set(zip(used, used[1:]))
A, B = parcel("dispatch absent dispatch deliver"), parcel("dispatch absent dispatch absent")
print("5.3 A", A[:2], "\n B", B[:2], "\n pairs", sorted(A[2] | B[2]))প্রথম লাইন: cells 42 valid 8 invalid 34 আর pairs 8 feasible 7. ৫.২-এর suite: states 5/7 0-switch 5/8 1-switch 3/7, বাদ পড়া চারটি জোড়ার তালিকাসহ। ৫.৪-এর suite-এ 0-switch 8/8, কিন্তু 1-switch 6/7 আর missing [('T7', 'T8')]. পার্সেলের দুটি test শেষ হয় 'Delivered' আর 'Returned'-এ, আর মিলে চারটি জোড়াই ঢাকে: ('P1', 'P2'), ('P1', 'P3'), ('P1', 'P4'), ('P3', 'P1').
৬ · Pairwise, orthogonal array আর classification tree
ঝালিয়ে নিন: পর্ব ১১ · Pairwise আর combinatorial testing. গুণের নিয়ম: ডিসক্রিট ম্যাথ কোর্সের পর্ব ৩১.
সব মিশ্রণ = মানের সংখ্যার গুণফল। মোট মান-জোড়া = প্রতিটি parameter-জোড়ার (a × b)-এর যোগফল। Pairwise-এর নিম্নসীমা = সবচেয়ে বড় দুটি parameter-এর মানের গুণফল। Orthogonal array-এ প্রতিটি জোড়া সমান সংখ্যকবার; covering array-এ অন্তত একবার। Constraint অসম্ভব সারি আর জোড়া বাদ দেয়।
৬.১(সহজ) Payment (cash, wallet, card), device (android, iphone, desktop), ভাষা (bn, en). সব মিশ্রণ, মোট মান-জোড়া আর নিম্নসীমা বের করুন, আর নিম্নসীমার সমান সারিতে একটি পূর্ণ pairwise suite দিন। (ঝালিয়ে নিন: পর্ব ১১)
all 3 x 3 x 2 = 18 ; pairs 9 + 6 + 6 = 21 ; lower bound 3 x 3 = 9
cash android bn | cash iphone en | cash desktop bn
wallet android en | wallet iphone bn | wallet desktop en
card android bn | card iphone en | card desktop bn
-> 21/21 pairs
আগে payment × device-এর ৯টি জোড়া এক সারিতে একবার করে বসান, তারপর ভাষা এমনভাবে দিন যাতে প্রতিটি payment আর প্রতিটি device দুই ভাষাই পায়। এখানে নিয়মটি: (payment-এর ক্রম + device-এর ক্রম) জোড় হলে bn.
৬.২(মাঝারি) চারটি parameter, প্রতিটির তিনটি মান (০, ১, ২)। L9 orthogonal array-এর কলাম: A, B, (A + B) mod 3, (A + 2B) mod 3, যেখানে A, B প্রতিটি ০–২. (ক) সারি কয়টি, সব মিশ্রণ কয়টি? (খ) মোট মান-জোড়া কত, আর প্রতিটি সারি কয়টি জোড়া ঢাকে? (গ) কেন কোনো সারি বাদ দেওয়া যায় না? (ঝালিয়ে নিন: পর্ব ১১)
(a) 9 rows vs 3^4 = 81
(b) column pairs C(4,2) = 6, each 9 value pairs -> 54 ; each row covers 6
(c) 9 rows x 6 = 54 = all pairs, each exactly once -> no slack:
drop any row and 6 pairs are lost
সমান আকারের parameter-এ orthogonal array নিখুঁত: নিম্নসীমা ৩ × ৩ = ৯-এই পৌঁছায়। মিশ্র আকারে (যেমন চার-মানের device) এমন array প্রায়ই নেই, তখন covering array.
৬.৩(মাঝারি) Checkout: জেলা (Dhaka, Ctg, Rajshahi), payment ৩টি, slot (morning, afternoon, evening), device ৪টি, ভাষা ২টি। (ক) সব মিশ্রণ, মান-জোড়া আর নিম্নসীমা? (খ) Constraint “ঢাকার বাইরে evening নেই” যোগ করলে সম্ভব সারি আর জোড়া? (গ) পর্ব ১১-এর greedy generator দুই ক্ষেত্রে কয়টি test দেয়? (ঝালিয়ে নিন: পর্ব ১১)
(a) 3 x 3 x 3 x 4 x 2 = 216 ; pairs 89 ; lower bound 4 x 3 = 12
(b) remove Ctg/Rajshahi x evening rows: 2 x 3 x 1 x 4 x 2 = 48
-> 168 rows ; pairs 89 - 2 = 87
(c) greedy: 13 tests unconstrained, 14 with the constraint
পর্ব ১১-এ PICT 3.7.4-ও constraint-সহ ১৪টি সারি দিয়েছিল। সেখানকার আরও দুটি সংখ্যা: base-choice-এর ১১টি test ঢাকে ৮৯-এর মাত্র ৫০টি জোড়া (৫৬.২%), আর 3-way-এ ২৪৩টি triple ঢাকতে ৪৬টি test.
৬.৪(মাঝারি) Classification tree পদ্ধতিতে (Grochtmann ও Grimm, ১৯৯৩) input-কে classification-এ ভাগ করে প্রতিটির class গাছের পাতায় আঁকা হয়, তারপর সারিতে প্রতিটি classification থেকে একটি class বেছে test. Checkout-এর গাছ: জেলা (ঢাকা, বাইরে), মোট (≤১০০০, ১০০১–১৯৯৯, ২০০০–২৯৯৯, ≥৩০০০), Plus (হ্যাঁ, না) আর payment (cash, wallet, card) মিলে চারটি ভাগ। (ক) পাতা কয়টি? (খ) প্রতিটি class অন্তত একবার: সর্বনিম্ন সারি? (গ) সব মিশ্রণ? (ঘ) Pairwise-এর জোড়া আর নিম্নসীমা? (ঝালিয়ে নিন: পর্ব ০৭, ১১)
(a) 2 + 4 + 2 + 3 = 11 leaves
(b) max = 4 rows (the total classification has 4 classes)
(c) 2 x 4 x 2 x 3 = 48
(d) pairs 8+4+6+8+12+6 = 44 ; lower bound 4 x 3 = 12
মোটের চারটি class এসেছে coupon আর delivery-র সীমা থেকে, অর্থাৎ গাছটি EP-কে ছবিতে আঁকে আর মিশ্রণ বাছার নিয়ম আলাদা রাখে। এই কোর্সে পদ্ধতিটির আলাদা পর্ব নেই; প্রশ্নের সংজ্ঞাটুকুই যথেষ্ট।
from itertools import combinations, product
from math import prod
def pairs(row): # all (column, value) pairs of a row
return {((i, row[i]), (j, row[j])) for i, j in combinations(range(len(row)), 2)}
def need(levels, ok=lambda r: True):
return set().union(*(pairs(r) for r in product(*map(range, levels)) if ok(r)))
def greedy(levels, ok=lambda r: True): # same idea as the generator of পর্ব ১১
rows = [r for r in product(*map(range, levels)) if ok(r)]
left, suite = need(levels, ok), []
while left:
best = max(rows, key=lambda r: len(pairs(r) & left))
left -= pairs(best); suite.append(best)
return len(rows), suite
lv = [3, 3, 2] # 6.1 payment, device, language
rows = [(p, d, (p + d) % 2) for p in range(3) for d in range(3)]
print("6.1 all", prod(lv), "| pairs", len(need(lv)), "| 9 rows cover",
len(set().union(*map(pairs, rows))))
L9 = [(a, b, (a + b) % 3, (a + 2 * b) % 3) for a in range(3) for b in range(3)]
each_once = all(sorted((r[i], r[j]) for r in L9) == sorted(product(range(3), repeat=2))
for i, j in combinations(range(4), 2))
print("6.2 L9 every pair exactly once:", each_once, "| pairs", len(need([3] * 4)))
lv = [3, 3, 3, 4, 2] # 6.3 district payment slot device lang
n, s = greedy(lv)
print("6.3 rows", n, "| pairs", len(need(lv)), "| greedy tests", len(s))
ok = lambda r: r[0] == 0 or r[2] != 2 # outside Dhaka: no evening slot
n, s = greedy(lv, ok)
print("6.3 constrained rows", n, "| pairs", len(need(lv, ok)), "| greedy tests", len(s))
lv = [2, 4, 2, 3] # 6.4 classification tree
print("6.4 classes", sum(lv), "| each-class tests", max(lv), "| all", prod(lv),
"| pairs", len(need(lv)), "| pairwise lower bound", 4 * 3)৬.১: all 18 | pairs 21 | 9 rows cover 21, অর্থাৎ নয় সারির suite-টি পূর্ণ। L9-এ every pair exactly once: True আর pairs 54. Checkout-এ rows 216 | pairs 89 | greedy tests 13, constraint-সহ rows 168 | pairs 87 | greedy tests 14: পর্ব ১১-এর সংখ্যাই। Greedy প্রতিবার সবচেয়ে বেশি নতুন জোড়ার সারি নেয়, তাই নিম্নসীমা ১২-র কাছাকাছি থাকে, ঠিক ১২ নয়। শেষ লাইনে classification tree: classes 11 | each-class tests 4 | all 48 | pairs 44.
৭ · Use case, scenario আর constraint-সহ গোনা
ঝালিয়ে নিন: পর্ব ১২ · Use case আর scenario testing, পর্ব ১৬ · Test case লেখা.
৭.১(সহজ) Checkout use case UC-05: মূল পথ ৭ ধাপ; extension 2a (stock শেষ, ফেরে), 3a (phone ভুল, ফেরে), 4a (coupon, ফেরে), 5a (cash on delivery, সফল শেষ), 6a (wallet রাজি নয়, আবার চেষ্টা → ধাপ ৫), 6b (wallet রাজি নয়, ক্রেতা বাতিল, ব্যর্থ শেষ)। (ক) ন্যূনতম scenario? (খ) প্রতিটি extension সর্বোচ্চ একবার ধরলে মোট পথ? (ঝালিয়ে নিন: পর্ব ১২)
(a) 1 main + 6 extensions = 7
(b) 2a, 3a, 4a each on/off: 2 x 2 x 2 = 8
from step 5: ok | 5a | 6b | 6a+ok | 6a+5a | 6a+6b = 6
8 x 6 = 48 paths
৪৮টির সব চালানো লাভজনক নয়; ঝুঁকি দেখে মিশ্রণ বাছুন। পর্ব ১২-এ বাড়তি নেওয়া হয়েছিল coupon তারপর ব্যর্থ চেষ্টা আর আবার চেষ্টা, আর ঠিক সেখানেই defect মিলেছিল: [1680] != [1890], ছাড় দুবার বাদ।
৭.২(মাঝারি) “UC-09 রিভিউ লেখা”: ১. ক্রেতা delivered অর্ডার থেকে ফর্ম খোলেন; ২. তারা বাছেন; ৩. লেখা দেন; ৪. পাঠান; ৫. System রিভিউ রাখে আর গড় নতুন করে দেখায়। Extension: 1a অর্ডার delivered নয় → ফর্ম নেই, ব্যর্থ শেষ; 2a তারা নেই → বার্তা, ধাপ ২-এ ফেরে; 3a লেখা ১০–৫০০-এর বাইরে → বার্তা, ধাপ ৩-এ ফেরে; 4a আগেই রিভিউ করা → বার্তা, ব্যর্থ শেষ। (ক) ন্যূনতম scenario আর সব পথ (প্রতিটি extension সর্বোচ্চ একবার)? (খ) পণ্যের আগের রিভিউ ৪, ৪, ৫, ৪; নতুন রিভিউ ৫ তারা হলে আগে আর পরে গড় কী দেখাবে (এক দশমিক, half up)? ১ তারা হলে? (ঝালিয়ে নিন: পর্ব ১২, ১৫)
(a) minimal 1 + 4 = 5
paths: 1a alone (1) + [2a on/off x 3a on/off] x [ok | 4a] (4 x 2) = 9
(b) before 17/4 = 4.25 -> "4.3" (half up)
+5 : 22/5 = 4.4 -> "4.4" ; +1 : 18/5 = 3.6 -> "3.6"
trap: Python round(4.25, 1) gives 4.2
Guarantee যাচাই না করলে scenario test অর্ধেক কাজ করে: সফল পথে গড় বদলায়, 4a-তে গড় আর রিভিউর সংখ্যা অপরিবর্তিত থাকে। round()-এর ফাঁদ banker's rounding-এর মতো আচরণ; AC5 চায় half up, তাই expected হাতে হিসাব করুন।
৭.৩(মাঝারি) রিভিউ ফর্মের test-এর চারটি ঘর: তারা (১–৫), লেখার ধরন (ছোট বৈধ, লম্বা বৈধ, বাংলা ও emoji), device (android, iphone, desktop), অর্ডার (delivered, delivered নয়)। Constraint: delivered না হলে ফর্মই দেখা যায় না, তাই তারা আর লেখা অর্থহীন। সম্ভব আলাদা মিশ্রণ কয়টি? Constraint না মানলে কয়টি গোনা হতো? (ঝালিয়ে নিন: পর্ব ১১, ১২)
delivered : 5 x 3 x 3 = 45
not delivered : stars, text irrelevant -> 3 (one per device)
feasible : 45 + 3 = 48
naive : 5 x 3 x 3 x 2 = 90
“delivered নয়” অংশে ৪৫টি সারি গুনলে ৪২টি অর্থহীন সারি suite-এ ঢোকে। Constraint মানে অসম্ভব মিশ্রণ বাদ; কিন্তু “delivered নয় এমন অর্ডারে API সরাসরি ডেকে রিভিউ পাঠানো” একটি আলাদা negative test হিসেবে থাকবেই।
from itertools import product
from decimal import Decimal, ROUND_HALF_UP
# 7.1 UC-05 checkout: 2a, 3a, 4a optional; from step 5 each extension at most once
ends = [["ok"], ["5a"], ["6b"], ["6a", "ok"], ["6a", "5a"], ["6a", "6b"]]
paths = [[x for x, on in zip(["2a", "3a", "4a"], bits) if on] + e
for bits in product([0, 1], repeat=3) for e in ends]
print("7.1 minimal", 1 + 6, "| all paths", len(paths))
# 7.2 review use case: 1a ends at once; 2a, 3a loop back once; 4a ends
paths = [["1a"]] + [[x for x, on in zip(["2a", "3a"], bits) if on] + [end]
for bits in product([0, 1], repeat=2) for end in ["ok", "4a"]]
print("7.2 minimal", 1 + 4, "| all paths", len(paths))
def shown(stars): # AC5: one decimal, half up
avg = Decimal(sum(stars)) / len(stars)
return str(avg.quantize(Decimal("0.1"), rounding=ROUND_HALF_UP))
rice = [4, 4, 5, 4]
print("7.2 before", shown(rice), "| +5", shown(rice + [5]), "| +1", shown(rice + [1]),
"| float round(4.25, 1) =", round(4.25, 1))
# 7.3 review form, constraint: not delivered -> form hidden
stars, text, device = range(1, 6), ["short", "long", "bn+emoji"], ["android", "iphone", "desktop"]
rows = {(st, tx, dv, "delivered") for st, tx, dv in product(stars, text, device)}
rows |= {("-", "-", dv, "not delivered") for dv in device}
print("7.3 feasible rows", len(rows), "| without the constraint", 5 * 3 * 3 * 2)UC-05-এ minimal 7 | all paths 48, রিভিউর use case-এ minimal 5 | all paths 9. গড়ের লাইন AC5-এর ফাঁদটি দেখায়: half up-এ before 4.3, নতুন ৫ তারায় 4.4, ১ তারায় 3.6; কিন্তু Python-এর round(4.25, 1) = 4.2. শেষ লাইনে constraint মানা feasible rows 48, না মানলে 90.
৮ · White-box — statement, branch, MC/DC, path আর def-use
ঝালিয়ে নিন: পর্ব ১৩ · White-box testing. Complexity-র প্রথম পরিচয়: সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৫০.
Statement = চলা statement ÷ মোট; branch = নেওয়া T/F তীর ÷ মোট তীর। MC/DC: প্রতিটি condition-এর একটি independence pair (শুধু সেটি বদলায়, ফলও বদলায়); সাধারণত n + 1টি test. V(G) = E − N + 2 = decision + 1. Def-use pair: একটি চলকের মান বসানো (def) থেকে ব্যবহার (use) পর্যন্ত, মাঝে নতুন def ছাড়া একটি পথ।
৮.১ আর ৮.২ এই function নিয়ে (লাইন নম্বর বাঁয়ে):
1 def review_error(delivered, stars, text):
2 if not delivered:
3 return "not_eligible"
4 if not isinstance(stars, int) or stars < 1 or stars > 5:
5 return "bad_stars"
6 n = len(text.strip())
7 if n < 10 or n > 500:
8 return "bad_text"
9 return None
৮.১(সহজ) ওপরের review_error-এ (লাইন ২–৯ executable; branch: 2→3, 2→4, 4→5, 4→6, 7→8, 7→9) (ক) statement আর branch item কয়টি? (খ) test (True, 5, "চাল খুব ভালো") আর (False, 5, "চাল খুব ভালো") চালালে দুই coverage কত? (গ) ১০০% করতে আর কোন দুটি test? (ঘ) decision-স্তরে আর প্রতিটি condition আলাদা ধরে V(G) কত? (ঝালিয়ে নিন: পর্ব ১৩)
(a) statements 8 (lines 2-9) ; branches 3 decisions x 2 = 6
(b) test 1 runs 2 4 6 7 9 ; test 2 adds 3
statement 6/8 = 75% ; branch 4/6 = 66.7% ; missing lines 5, 8
(c) (True, 0, "চাল খুব ভালো") -> bad_stars ; (True, 4, "ভালো চাল") -> bad_text
(d) decisions 3 -> V(G) = 4 ; conditions 1 + 3 + 2 = 6 -> 7
“চাল খুব ভালো” ১২টি code point, “ভালো চাল” ৮টি (৩.২): তাই দ্বিতীয়টি লাইন ৮-এ যায়। চারটি test-এ দুই coverage ১০০%.
৮.২(মাঝারি) ৮.১-এর চারটি test-এ statement আর branch দুটোই ১০০%. তবু AC2 বলে JSON-এর true তারা হিসেবে প্রত্যাখ্যাত হবে। (True, True, "চাল খুব ভালো") দিলে function কী ফেরত দেয়, কেন, আর কোন coverage মাপ এটি ধরতে পারত না? ঠিক করুন। (ঝালিয়ে নিন: পর্ব ১৩, ০৭)
review_error(True, True, "চাল খুব ভালো") -> None (accepted!)
bool is a subclass of int: isinstance(True, int) is True, True == 1
fix: if isinstance(stars, bool) or not isinstance(stars, int) or ...
(or: type(stars) is not int)
কোনো coverage মাপই ধরে না, কারণ ভুলটি “না-চলা কোড” নয়, ভুল দলের মান। এটি ধরে ২.৪-এর partition “সংখ্যা নয় (true)”, অর্থাৎ black-box নকশা। Coverage বলে কী চলেনি; কী ভুল, তা বলে না।
৮.৩(মাঝারি) একটি কাল্পনিক নিয়ম: wallet payment চলবে যদি (A or B) and not C, যেখানে A = phone যাচাই করা, B = আগে অন্তত একটি অর্ডার, C = account সাময়িক আটকানো। (ক) প্রতিটি condition-এর independence pair. (খ) ন্যূনতম MC/DC set. (গ) Multiple-condition coverage-এ কয়টি? (ঝালিয়ে নিন: পর্ব ১৩)
true rows: TTF, TFF, FTF
(a) A: TFF-FFF only ; B: FTF-FFF only
C: TTT-TTF, TFT-TFF, FTT-FTF
(b) forced TFF, FFF, FTF ; C needs one more row:
{FFF, FTF, TFF, TFT} or {FFF, FTF, FTT, TFF} -> 4 = n + 1
(c) 2^3 = 8
নিচের stepper বাছাইয়ের ধাপগুলো দেখায়। Concrete রূপে একটি set: (যাচাই নয়, নতুন, খোলা) → না; (যাচাই নয়, পুরোনো, খোলা) → হ্যাঁ; (যাচাই, নতুন, খোলা) → হ্যাঁ; (যাচাই, নতুন, আটকানো) → না।
8 rows, true only:
TTF TFF FTF
(C must be F, A or B T)
flip A, result flips only
when B = F, C = F:
TFF ↔ FFF (forced)
FTF ↔ FFF (forced)
set so far:
FFF FTF TFF
TTT↔TTF TFT↔TFF FTT↔FTF
reuse TFF: add TFT
(or reuse FTF: add FTT)
{FFF, FTF, TFF, TFT}
4 tests = n + 1
all 8 rows: 8 tests
- সত্য-সারণি। আটটি সারির তিনটিতে ফল সত্য: C মিথ্যা, আর A বা B অন্তত একটি সত্য।
- A-র জোড়া। B সত্য হলে or এমনিতেই সত্য, C সত্য হলে and এমনিতেই মিথ্যা; একে masking বলে। তাই A-র জোড়া একটিই, বাধ্যতামূলক।
- B-র জোড়া। একইভাবে একটিই; FFF দুই জোড়ায় ভাগ হলো, তাই তিন সারিতে A আর B দুটোর প্রমাণ।
- C-র জোড়া। তিনটি জোড়া; যেটির একটি সারি আগেই আছে সেটি নিলে নতুন সারি মাত্র একটি।
- ফল। চারটি test = n + 1; চেকার সব উপসেট খুঁজে ঠিক দুটি ন্যূনতম set পেয়েছে।
৮.৪(মাঝারি) bulk_discount(lines): total = 0; প্রতিটি (price, qty)-এর জন্য: qty ≤ 0 হলে continue; qty ≥ 10 হলে total-এ price × qty × 95 // 100 যোগ; নইলে price × qty যোগ; শেষে return total. CFG-এর node: ১ total = 0, ২ for-এর মাথা, ৩ qty ≤ 0?, ৪ continue, ৫ qty ≥ 10?, ৬ bulk যোগ, ৭ সাধারণ যোগ, ৮ return. (ক) N, E আর V(G)? (খ) সর্বোচ্চ ০, ১, ২, ৩ ঘূর্ণনে entry থেকে exit পথ কয়টি? (গ) Loop coverage-এ কোন ঘূর্ণন নেবেন? (ঝালিয়ে নিন: পর্ব ১৩)
(a) edges 1-2, 2-3, 2-8, 3-4, 3-5, 4-2, 5-6, 5-7, 6-2, 7-2
N = 8, E = 10, V(G) = 10 - 8 + 2 = 4 (= 3 decisions + 1)
(b) each turn: skip | bulk | normal -> 3 ways
at most k turns: 1, 4, 13, 40 ( = (3^(k+1) - 1) / 2 )
(c) 0 lines, 1 line, 2 lines (a skip then a normal line), a typical
cart ; and for bulk: qty 9, 10, 11 inside one line
Basis path-এর ৪টি test-এ branch পূর্ণ হয়, কিন্তু পথ ঘূর্ণনের সাথে গুণ হারে বাড়ে। শেষ লাইনটি loop-এর ভেতরের সীমা: qty 10-এ ছাড় শুরু, আর “১০ বা বেশি” লেখা আছে কি না দেখে নিন।
৮.৫(কঠিন) Data-flow testing-এ (Rapps ও Weyuker, ১৯৮৫) প্রতিটি def থেকে তার use-এ মাঝে নতুন def ছাড়া পথ চালাতে হয়। Function: ১ def bill(total, dhaka, coupon): ২ discount = 0 ৩ if coupon and total > 1000: ৪ discount = min(total // 10, 300) ৫ charge = 60 if dhaka else 120 ৬ if dhaka and total >= 2000: ৭ charge = 0 ৮ return total - discount + charge. (ক) discount আর charge-এর def-use pair? (খ) সব pair ঢাকতে সর্বনিম্ন test? (গ) (1500, True, False) কি নতুন কিছু ঢাকে? (ঝালিয়ে নিন: পর্ব ১৩)
(a) discount: (2,8) needs line 4 skipped ; (4,8)
charge : (5,8) needs line 7 skipped ; (7,8) -> 4 pairs
(b) 2 tests: (2500, Dhaka, coupon) -> 2250 covers (4,8) (7,8)
(500, outside, no coupon) -> 620 covers (2,8) (5,8)
(c) (1500, Dhaka, no coupon) -> 1560 : (2,8) (5,8) again, nothing new
(2, 8)-এর জন্য coupon-ওয়ালা test চলে না: লাইন ৪ আগের মান মুছে দেয়, পথ আর “def-clear” থাকে না। এই কোর্সে data-flow-এর আলাদা পর্ব নেই; branch coverage-এর পাশে এটি দেখায় কোন মান আসলে কোথায় পৌঁছায়।
import ast, sys
SRC = '''def review_error(delivered, stars, text):
if not delivered:
return "not_eligible"
if not isinstance(stars, int) or stars < 1 or stars > 5:
return "bad_stars"
n = len(text.strip())
if n < 10 or n > 500:
return "bad_text"
return None
'''
fn = ast.parse(SRC).body[0]
STMTS = {x.lineno for x in ast.walk(fn) if isinstance(x, ast.stmt)} - {1}
BRANCHES = {(2, 3), (2, 4), (4, 5), (4, 6), (7, 8), (7, 9)} # (if line, next line)
ns = {}; exec(compile(SRC, "review.py", "exec"), ns)
lines, arcs, prev = set(), set(), [None]
def tracer(frame, event, arg):
if frame.f_code.co_name == "review_error" and 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 args in [(True, 5, "চাল খুব ভালো"), (False, 5, "চাল খুব ভালো"),
(True, 0, "চাল খুব ভালো"), (True, 4, "ভালো চাল"), (True, True, "চাল খুব ভালো")]:
prev[0] = None; sys.settrace(tracer); out = ns["review_error"](*args); sys.settrace(None)
s, b = len(lines & STMTS), len(arcs & BRANCHES)
print(f"{args[:2]} -> {out!r:15} stmt {s}/{len(STMTS)} branch {b}/{len(BRANCHES)}")
ifs = [x for x in ast.walk(fn) if isinstance(x, ast.If)]
conds = sum(len(x.test.values) if isinstance(x.test, ast.BoolOp) else 1 for x in ifs)
print("V(G): decisions", len(ifs), "->", len(ifs) + 1, "| conditions", conds, "->", conds + 1)প্রতিটি সারি জমা হিসাব দেখায়: প্রথম test-এর পরে stmt 5/8 branch 3/6, দ্বিতীয়টির পরে 6/8 আর 4/6, চতুর্থটির পরে 8/8 আর 6/6. পঞ্চম সারিটিই ৮.২-এর প্রশ্ন: (True, True) -> None, অর্থাৎ True তারা হিসেবে গৃহীত, অথচ coverage আগেই পূর্ণ, তাই কোনো নতুন লাইন বা তীর যোগ হয়নি। শেষ লাইনে decisions 3 -> 4 | conditions 6 -> 7.
from itertools import product, combinations
D = lambda a, b, c: (a or b) and not c # 8.3 (A or B) and not C
rows = list(product([1, 0], repeat=3))
name = lambda r: "".join("TF"[1 - v] for v in r)
print("8.3 true rows:", [name(r) for r in rows if D(*r)])
pairs = {k: [(name(r), name(s)) for r, s in combinations(rows, 2)
if [i for i in range(3) if r[i] != s[i]] == [k] and D(*r) != D(*s)]
for k in range(3)}
for k, p in pairs.items(): print(" ", "ABC"[k], "pairs:", p)
def mcdc(tests): # every condition shows a pair?
return all(any(a in tests and b in tests for a, b in pairs[k]) for k in range(3))
names = [name(r) for r in rows]
best = [set(c) for n in range(1, 9) for c in combinations(names, n) if mcdc(set(c))]
size = min(map(len, best))
print("8.3 minimum", size, "| sets:", [sorted(s) for s in best if len(s) == size])
# 8.4 CFG of bulk_discount: 1 total=0, 2 for, 3 qty<=0, 4 continue,
# 5 qty>=10, 6 bulk add, 7 normal add, 8 return
G = {1: [2], 2: [3, 8], 3: [4, 5], 4: [2], 5: [6, 7], 6: [2], 7: [2], 8: []}
N, E = len(G), sum(map(len, G.values()))
print("8.4 N", N, "E", E, "V(G) = E-N+2 =", E - N + 2)
def paths(node, turns_left): # count entry-exit paths
if node == 8: return 1
total = 0
for nxt in G[node]:
if (node, nxt) == (2, 3): # one more loop turn
if turns_left: total += paths(nxt, turns_left - 1)
else: total += paths(nxt, turns_left)
return total
print("8.4 paths with at most k turns:", [paths(1, k) for k in range(4)])Truth table-এ সত্য সারি ['TTF', 'TFF', 'FTF']. A আর B-র জোড়া একটি করে, C-র তিনটি। সব উপসেট খুঁজে minimum 4, আর ন্যূনতম set ঠিক দুটি: ['FFF', 'FTF', 'TFF', 'TFT'] আর ['FFF', 'FTF', 'FTT', 'TFF']. CFG-এর লাইনে N 8 E 10 V(G) = E-N+2 = 4, আর পথের গণনা [1, 4, 13, 40]: প্রতিটি নতুন ঘূর্ণন আগের পথগুলোকে তিন ভাগে ভাঙে।
import sys
SRC = '''def bill(total, dhaka, coupon):
discount = 0
if coupon and total > 1000:
discount = min(total // 10, 300)
charge = 60 if dhaka else 120
if dhaka and total >= 2000:
charge = 0
return total - discount + charge
'''
DEFS = {"discount": {2, 4}, "charge": {5, 7}} # the use of both: line 8
ns = {}; exec(compile(SRC, "bill.py", "exec"), ns)
order = []
def tracer(frame, event, arg):
if frame.f_code.co_name == "bill" and event == "line": order.append(frame.f_lineno)
return tracer
covered = set()
for args in [(2500, True, True), (500, False, False), (1500, True, False)]:
order.clear(); sys.settrace(tracer); out = ns["bill"](*args); sys.settrace(None)
du = {([l for l in order if l in lines][-1], 8) for lines in DEFS.values()}
covered |= du
print(args, "->", out, "| du-pairs reaching line 8:", sorted(du))
print("all 4 du-pairs covered:", sorted(covered), len(covered) == 4)প্রথম test 2250 (২৫০০ − ২৫০ + ০) দেয় আর ঢাকে (4, 8), (7, 8); দ্বিতীয়টি 620 (৫০০ − ০ + ১২০) আর ঢাকে (2, 8), (5, 8). তৃতীয়টি 1560 দিলেও নতুন কোনো pair আনেনি। শেষ লাইন True: দুটি test-এই চারটি def-use pair. চেকার sys.settrace দিয়ে চলা লাইনের ক্রম রাখে, আর প্রতিটি চলকের শেষ চলা def-কেই লাইন ৮-এ পৌঁছানো def ধরে।
৯ · Mutation score আর random input-এর হিসাব
ঝালিয়ে নিন: পর্ব ৫৯ · Mutation testing, পর্ব ৫৮ · Property-based testing.
৯.১(সহজ) একটি pricing module-এ line আর branch coverage ১০০%; mutation tool ৭৪টি mutant বানাল, ৬৩টি killed, ১১টি survived. (ক) Mutation score? (খ) সাতটি নতুন test-এর পরে ৭৩টি killed: score? (গ) প্রথম run-এর ১১টি survivor-এর একটি equivalent প্রমাণ হলে প্রথম score? (ঘ) ২০০টি mutant, ১৫০টি killed, ১০টি equivalent? (ঝালিয়ে নিন: পর্ব ৫৯)
(a) 63 / 74 = 85.1%
(b) 73 / 74 = 98.6%
(c) 63 / (74 - 1) = 86.3%
(d) 150 / (200-10) = 78.9%
(ক) আর (খ) পর্ব ৫৯-এর cosmic-ray 8.9.0-এর সত্যিকারের run-এর সংখ্যা। শেষ survivor ছিল == থেকে is, যা দেখতে equivalent কিন্তু নয়; runtime-এ বানানো “Dhaka” লেখায় ধরা পড়ে, আর অষ্টম test-এ ৭৪/৭৪.
৯.২(মাঝারি) তারার নিয়মের কোড return 1 <= s <= 5. Tool সাতটি mutant দিল: (ক) 1 < s <= 5, (খ) 1 <= s < 5, (গ) 0 <= s <= 5, (ঘ) 1 <= s <= 6, (ঙ) 2 <= s <= 5, (চ) 1 <= s <= 4, (ছ) 1 <= s or s <= 5. সবচেয়ে কম কয়টি s-এর মানে সাতটিই মরে, কোনগুলো? (ঝালিয়ে নিন: পর্ব ৫৯, ০৮)
s = 0 kills (গ) (ছ) ; s = 1 kills (ক) (ঙ)
s = 5 kills (খ) (চ) ; s = 6 kills (ঘ) (ছ) ; s = 3 kills none
(গ) needs 0, (ঘ) needs 6, (ক)/(ঙ) need 1, (খ)/(চ) need 5
-> smallest set {0, 1, 5, 6} : 4 values
উত্তরটি হুবহু তারার ২-মান BVA set (৩.২-এর খ)। ভেতরের মান ৩ একটিও মারে না: সীমার mutant সীমাতেই মরে।
৯.৩(কঠিন) Coupon-এর >-কে >= করা mutant ১ থেকে ৫০০১-এর মধ্যে শুধু ১০০০-এ আলাদা ফল দেয়। প্রতি run-এ এই পরিসর থেকে ১০০টি স্বাধীন এলোমেলো মান (সমান সম্ভাবনা, পুনরাবৃত্তি চলে) নিলে (ক) এক run-এ ১০০০ পড়ার সম্ভাবনা? (খ) ৫০% আর ৯৫% সম্ভাবনার জন্য কয়টি মান লাগে? (গ) এ থেকে property-based testing নিয়ে শিক্ষা? (ঝালিয়ে নিন: পর্ব ৫৮, ৫৯)
(a) 1 - (5000/5001)^100 = 1.98%
(b) n >= ln(1 - p) / ln(5000/5001) : 50% -> 3467 ; 95% -> 14981
(c) random input rarely lands on a boundary: keep 1000 as a fixed example
পর্ব ৫৯-এর পরীক্ষায় ১০০০টি run-এর মাত্র ২০টিতে ১০০০ পড়েছিল, হিসাবের কাছাকাছি। পর্ব ৫৮-এ Hypothesis-এর ১০০টি উদাহরণে coupon-এর এই ভুল ২০টি seed-এর ৮টিতে ধরা পড়েনি; তাই জানা সীমা @example-এ লিখে রাখা হয়।
from itertools import combinations
from math import log, ceil
score = lambda killed, total, equiv=0: f"{100 * killed / (total - equiv):.1f}%"
print("9.1 first run", score(63, 74), "| after 7 tests", score(73, 74),
"| if 1 survivor were equivalent", score(63, 74, 1), "| 150/200, 10 eq", score(150, 200, 10))
good = lambda s: 1 <= s <= 5 # 9.2 stars rule and 7 mutants
M = {"ক": lambda s: 1 < s <= 5, "খ": lambda s: 1 <= s < 5, "গ": lambda s: 0 <= s <= 5,
"ঘ": lambda s: 1 <= s <= 6, "ঙ": lambda s: 2 <= s <= 5, "চ": lambda s: 1 <= s <= 4,
"ছ": lambda s: 1 <= s or s <= 5}
kills = lambda vals: {k for k, m in M.items() for v in vals if m(v) != good(v)}
for v in (0, 1, 3, 5, 6): print("9.2 s =", v, "kills", sorted(kills([v])))
cand = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 10]
for n in range(1, 6):
hit = [c for c in combinations(cand, n) if len(kills(c)) == 7]
if hit: print("9.2 smallest killing set: size", n, hit); break
p = 1 - (5000 / 5001) ** 100 # 9.3 random picks from 1..5001
print(f"9.3 P(1000 among 100 random picks) = {100 * p:.2f}%")
for want in (0.5, 0.95):
print(f"9.3 picks for {want:.0%} chance:", ceil(log(1 - want) / log(5000 / 5001)))Score-এর লাইন: 85.1%, 98.6%, 86.3% আর 78.9%. প্রতিটি মান কোন mutant মারে: s = 0 → গ, ছ; s = 1 → ক, ঙ; s = 5 → খ, চ; s = 6 → ঘ, ছ; আর ভেতরের s = 3 একটিও না ([])। সবচেয়ে ছোট set size 4 [(0, 1, 5, 6)], একটিই। শেষে 1.98%, আর ৫০% ও ৯৫% সম্ভাবনার জন্য 3467 ও 14981টি এলোমেলো মান।
১০ · নতুন নিয়মের test নকশা — মিশ্র সমস্যা আর আদর্শ উত্তর
এবার কৌশলের নাম বলা থাকবে না; কোনটি লাগবে, তা নিয়ম দেখে আপনি ঠিক করবেন। আদর্শ উত্তরে আগে কৌশল বাছাইয়ের কারণ, তারপর test-এর টেবিল, শেষে খোলা প্রশ্ন।
১০.১(মাঝারি) Cart-এর নিয়ম: “এক লাইনে ১ থেকে ১০টি, আর কখনো stock-এর বেশি নয়।” পণ্যের stock: চাল ৫০, ডাল ৮০, গুঁড়া দুধ ৩, চা পাতা ০. পরিমাণের test নকশা করুন: কোন কৌশল, কোন মান, expected কী? (ঝালিয়ে নিন: পর্ব ০৭, ০৮)
upper limit = min(10, stock) -> the boundary MOVES with stock
stock 50 : 0 reject | 1 ok | 10 ok | 11 reject
stock 10 : 10 ok | 11 reject (both limits meet)
stock 3 : 0 reject | 1 ok | 3 ok | 4 reject
stock 0 : 1 reject (nothing can be added)
দুটি input একটি শর্তে জড়ানো, তাই সীমা একটি বিন্দু নয়: domain testing-এর ধাঁচ। Stock-এর তিনটি দল (০, ১–৯, ১০ বা বেশি) EP থেকে, প্রতিটিতে BVA. খোলা প্রশ্ন: অন্য কেউ একই সময়ে শেষ দুধটি কিনলে কী হয়? সেটি concurrency test.
১০.২(মাঝারি) মোট বিল = পণ্যের মোট − coupon ছাড় + delivery (coupon: ১০০০-এর বেশি হলে ১০%, floor, সর্বোচ্চ ৩০০; delivery: ঢাকায় ৬০, ছাড়ের আগের মোট ≥ ২০০০ হলে ফ্রি; বাইরে ১২০, Plus ৬০)। (ক) এই ক্ষেত্রগুলোর বিল: ঢাকা ২০০০; ঢাকা ১৯৯৯; রাজশাহী Plus ২৫০০; Gazipur ৩০১০; Gazipur Plus ৩০১০; ঢাকা ১০০০. (খ) Developer ভুল করে ফ্রি delivery-র শর্তে ছাড়ের পরের অঙ্ক ধরলেন। কোন মোটগুলোতে ভুলটি দেখা যায়? (ঝালিয়ে নিন: পর্ব ০৯, ০৮)
(a) Dhaka 2000 2000 - 200 + 0 = 1800
Dhaka 1999 1999 - 199 + 60 = 1860
Rajshahi Plus 2500 2500 - 250 + 60 = 2310
Gazipur 3010 3010 - 300 + 120 = 2830
Gazipur Plus 3010 3010 - 300 + 60 = 2770
Dhaka 1000 1000 - 0 + 60 = 1060
(b) totals t >= 2000 with t - discount(t) < 2000 : 2000 .. 2221 = 222 values
নকশা: delivery-র decision table থেকে কলাম, প্রতিটি কলামে টাকার সীমা থেকে মান। ২৫০০-এর মতো “মাঝের” মান নিলে (খ)-এর ভুল লুকিয়ে থাকে, যেমন পর্ব ০৯-এর চালানো উদাহরণে হয়েছিল (1860 != 1800 শুধু ২০০০-এ)।
১০.৩(মাঝারি) রিভিউর নিয়মে একটি প্রশ্ন খোলা: delivery-র পরে কতদিন রিভিউ চলবে? ধরুন product owner উত্তর দিলেন “delivery-র মুহূর্ত থেকে ঠিক ৭ দিন পর্যন্ত, সীমার মুহূর্তসহ, ঢাকার সময়ে”। একটি অর্ডার delivered হলো ১০ নভেম্বর ২০২৬, বিকেল ৩টায়, ঢাকার সময়ে (UTC+6); server চলে UTC-তে। সময়ের সীমার ৩-মান test আর তাদের UTC রূপ লিখুন; আর কী জিজ্ঞেস করবেন? (ঝালিয়ে নিন: পর্ব ০৮, ১৫)
deadline 17 Nov 2026 15:00:00 Dhaka
17 Nov 14:59:59 Dhaka = 08:59:59 UTC -> accept
17 Nov 15:00:00 Dhaka = 09:00:00 UTC -> accept (inclusive)
17 Nov 15:00:01 Dhaka = 09:00:01 UTC -> reject
“৭ দিন” এই প্রশ্নের অনুমান; আসল নিয়মে এখনো খোলা। প্রশ্ন: সীমা কি মুহূর্তে, না ক্যালেন্ডারের দিনে (১৭ নভেম্বর রাত ১১:৫৯:৫৯ পর্যন্ত)? Delivered-এর সময় কে বসায়, রাইডারের app না server? ফর্ম খোলা অবস্থায় সীমা পেরোলে পাঠানো রিভিউ চলবে কি?
১০.৪(কঠিন) Coupon function-এর জন্য বাজেট সর্বোচ্চ ১২টি test. বিকল্প: (ক) ISTQB ২-মান set {0, 1, 1000, 1001, 3000, 3001} আর EP-র চারটি প্রতিনিধি {−50, 500, 2000, 5000}; (খ) ৩-মান set (১২টি) একা; (গ) ৩-মান set আর একই চারটি প্রতিনিধি। প্রতিটিতে কয়টি আলাদা test? পর্ব ০৮-এর ছয়টি mutant-এর পরীক্ষায় (ক) ৫টি, (খ) ৫টি, (গ) ৬টিই মেরেছিল; বাজেটের ভেতরে কোনটি নেবেন, কেন? (ঝালিয়ে নিন: পর্ব ০৮, ৫৯)
(a) 6 + 4 = 10 distinct tests -> 5/6 (misses round(t / 10))
(b) 12 tests -> 5/6 (misses the cap-301 mutant)
(c) 12 + 4 = 16 tests -> 6/6, but over the budget
choice: (a) + 2999 -> 11 tests, 6/6 ; the 12th by risk, e.g. 999
(ক) যে mutant ছাড়ে তা floor-এর বদলে কাছের পূর্ণ সংখ্যায় গোল করা, যাকে ধরে 2999 (২৯৯ বনাম ৩০০); আর (খ) যা ছাড়ে তা cap ৩০১, যাকে ধরে EP-র 5000. তাই (ক)-তে 2999 যোগ করলেই ১১টি test-এ ছয়টিই মরে (scratch-এ পর্ব ০৮-এর mutant দিয়ে মেলানো)। এই যুক্তি লিখে রাখাই ঝুঁকিভিত্তিক বাছাই, পর্ব ৭৩-এর বিষয়।
from datetime import datetime, timedelta, timezone
qty_ok = lambda q, stock: 1 <= q <= min(10, stock) # 10.1 cart line rule
for stock, qs in [(50, [0, 1, 10, 11]), (10, [10, 11]), (3, [0, 1, 3, 4]), (0, [1])]:
print(f"10.1 stock {stock:>2}:", [(q, "ok" if qty_ok(q, stock) else "reject") for q in qs])
coupon = lambda t: 0 if t <= 1000 else min(t // 10, 300)
def delivery(dist, t, plus=False): # threshold BEFORE coupon
if dist == "Dhaka": return 0 if t >= 2000 else 60
return 60 if plus else 120
bill = lambda dist, t, plus=False: t - coupon(t) + delivery(dist, t, plus)
for case in [("Dhaka", 2000), ("Dhaka", 1999), ("Rajshahi", 2500, True),
("Gazipur", 3010), ("Gazipur", 3010, True), ("Dhaka", 1000)]:
print("10.2", case, "->", bill(*case))
bug = [t for t in range(1001, 10000) if t >= 2000 and t - coupon(t) < 2000]
print("10.2 'after coupon' bug shows only at", bug[0], "..", bug[-1], "=", len(bug), "totals")
BD = timezone(timedelta(hours=6)) # 10.3 assumed 7-day window
delivered = datetime(2026, 11, 10, 15, 0, 0, tzinfo=BD)
deadline = delivered + timedelta(days=7)
for s in (-1, 0, 1):
t = deadline + timedelta(seconds=s)
print("10.3", t.strftime("%d %b %H:%M:%S"), "BD =", t.astimezone(timezone.utc).strftime("%H:%M:%S"), "UTC")
two = [0, 1, 1000, 1001, 3000, 3001] # 10.4 budget question
three = [-1, 0, 1, 2, 999, 1000, 1001, 1002, 2999, 3000, 3001, 3002]
ep = [-50, 500, 2000, 5000]
print("10.4 2v+EP", len(set(two + ep)), "| 3v+EP", len(set(three + ep)))Cart-এর চার লাইনে stock অনুযায়ী সীমা সরে যায়: stock ৩-এ (3, 'ok'), (4, 'reject'), stock ০-এ (1, 'reject'). বিলের ছয়টি ফল 1800, 1860, 2310, 2830, 2770, 1060; ভুলটি দেখা যায় শুধু 2000 .. 2221 = 222 totals-এ। সময়ের তিন লাইনে ঢাকার ১৫:০০:০০ মানে UTC 09:00:00. শেষে বাজেটের হিসাব 2v+EP 10 | 3v+EP 16.
শেষ মুহূর্তের সূত্র-তালিকা আর সাধারণ ভুল
| বিষয় | সূত্র | সাধারণ ভুল | পর্ব |
|---|---|---|---|
| EP | each-choice = max valid + ∑ invalid; base = ১ + ∑(দল − ১) | দুটি invalid এক test-এ; test গুনে coverage | ০৭ |
| BVA | সীমা = প্রতিটি দলের min, max; ৩-মান = সীমা ± ১ | রীতি না বলা; “বেশি” আর “বা বেশি” গোলানো; লুকানো সীমা ভোলা | ০৮ |
| Jorgensen | 4n + 1, 6n + 1, 5n, 7n | ISTQB-এর ২-মান/৩-মানের সাথে মেশানো | ০৮ |
| Decision table | 2n; rule-count = ∑ 2(− সংখ্যা) | অসম্ভব কলাম হরে রাখা; গোনা মিলল মানেই ঠিক ভাবা | ০৯ |
| State | ঘর = state × event; 1-switch = ∑ ঢোকা × বের হওয়া | guard ভোলা; এক test-এ কয়েকটি অবৈধ event | ১০ |
| Pairwise | জোড়া = ∑ a × b; নিম্নসীমা = বড় দুটির গুণ | “১০০%” দাবি না গুনে মানা; constraint ভোলা | ১১ |
| Use case | ন্যূনতম = ১ + extension | guarantee যাচাই না করা | ১২ |
| Coverage | V(G) = E − N + 2 = decision + 1; MC/DC ≈ n + 1 | def লাইন গোনা; coverage-কে সঠিকতা ভাবা | ১৩ |
| Mutation | killed ÷ (মোট − equivalent) | “দেখতে equivalent” mutant বাদ দেওয়া | ৫৯ |
২০ মিনিটের মিনি-সেট — ঘড়ি ধরে করুন
আটটি ছোট প্রশ্ন, প্রতিটিতে আড়াই মিনিট। কাগজ-কলম চলবে, চেকার নয়। ৭–৮ ঠিক হলে প্রস্তুত, ৫–৬ হলে সংশ্লিষ্ট ভাগ আবার, ৪-এর কম হলে ভাগ ২ থেকে আবার শুরু করুন।
- পরিমাণ ১–১০ বৈধ (০ বা কম আর ১১ বা বেশি অবৈধ)। ISTQB-আক্ষরিক ২-মান set?
- একই ঘরে ৩-মান set-এ কয়টি মান?
- চারটি Y/N শর্তের পূর্ণ decision table-এ কয়টি কলাম?
- ৫টি state আর ৪টি event-এর যন্ত্রে ৭টি বৈধ transition, প্রতিটি আলাদা ঘরে। অবৈধ ঘর কয়টি?
- চারটি parameter-এ ৪, ৩, ৩, ২টি মান। Pairwise-এর নিম্নসীমা?
- A and B and C-এ ন্যূনতম MC/DC set-এ কয়টি test?
- একটি function-এ দুটি if আর একটি while, যুক্ত শর্ত নেই। V(G)?
- ১২০টি mutant, ৯০টি killed, ১০টি equivalent. Mutation score?
উত্তরমিনি-সেটের উত্তর আর এক লাইনের কারণ (নিজে করার পরে খুলুন)
1. 0, 1, 10, 11 (partitions touch)
2. -1 0 1 2 9 10 11 12 -> 8
3. 2^4 = 16
4. 5 x 4 - 7 = 13
5. 4 x 3 = 12
6. TTT, FTT, TFT, TTF -> 4
7. 3 decisions + 1 = 4
8. 90 / (120 - 10) = 81.8%
সবচেয়ে বেশি ভুল হয় ২ আর ৮-এ: ৩-মানে অবৈধ দলের কিনারার প্রতিবেশী (−1, 12) ভুলে যাওয়া, আর equivalent mutant হর থেকে বাদ না দেওয়া (৯০ ÷ ১২০ = ৭৫% লেখা)।
AI-এর যুগে — AI-এর বানানো test নকশা যাচাই
AI সহকারীকে “এই নিয়মের boundary আর decision table দাও” বললে গোছানো টেবিল আসে। কিন্তু তাতে প্রায়ই শুধু happy path থাকে, ২-মান আর ৩-মান গুলিয়ে যায়, expected আসে কোড থেকে, আর “১০০% coverage” দাবি কেউ গুনে দেখে না। চেনা ভুলগুলো:
| AI-এর ভুল | উদাহরণ | কীভাবে ধরবেন |
|---|---|---|
| শুধু গোল মান | coupon-এ 500, 1500, 5000; 1000 বা 1001 নেই | নিজে সীমার তালিকা বানিয়ে মেলানো |
| কোড থেকে expected | ভুল >= কোড দেখে “1000-এ ছাড় 100” | প্রতিটি expected requirement-এর বাক্য থেকে হিসাব |
| ভুল গোনা | “৩-মান” বলে ২-মানের মান; জোড়া না গুনে “pairwise ১০০%” | এই পাতার চেকারের মতো ছোট script |
| Constraint আর guard ভোলা | T5 → T8-কে বৈধ জোড়া গোনা; ঢাকার বাইরে evening সারি | প্রতিটি সারি নিয়মে চালিয়ে দেখা |
| দুর্বল assertion | assert result >= 0, ব্যর্থতা গিলে ফেলা try/except | কোডে ভুল বসিয়ে (mutant) test লাল হয় কি না দেখা |
| না চালিয়ে “সব পাস” | run-এর আউটপুট ছাড়াই দাবি | নিজে চালানো; ব্যর্থ test-এর বার্তা পড়া |
AI-কে উত্তরদাতা নয়, পর্যালোচক হিসেবে ব্যবহার করুন: আগে নিজের নকশা দিন, যাতে সে ফাঁক দেখায়।
যাচাইয়ের চেকলিস্ট
নিজেকে যাচাই করুন
প্রতিটি প্রশ্নে খাতায় হিসাব করে তবে উত্তর বাছুন। সব তথ্য প্রশ্নের ভেতরেই আছে।
ক্রমএকটি নতুন সংখ্যার নিয়ম থেকে boundary test নকশার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Requirement পড়ে input, তার ধরন আর ক্ষুদ্রতম ধাপ লেখা
- বৈধ আর অবৈধ partition ক্রম অনুযায়ী সাজানো
- প্রতিটি partition-এর সর্বনিম্ন আর সর্বোচ্চ মান, অর্থাৎ সীমা লেখা
- ঝুঁকি দেখে ২-মান না ৩-মান ঠিক করে coverage item-এর তালিকা বানানো
- প্রতিটি মানের expected requirement থেকে হিসাব করে test চালানো
(সহজ) “অর্ডার ২০০০ টাকা বা বেশি হলে ফ্রি delivery” (মোট পূর্ণ টাকা, ১-এর কম হলে ভুলের বার্তা)। ঢাকার জন্য ISTQB-আক্ষরিক ২-মান set কোনটি?
- 1999, 2000
- 0, 1, 1999, 2000
- 0, 1, 2000, 2001
- 1998, 1999, 2000, 2001
(মাঝারি) দুটি শর্তের decision table: C1 মোট > ১০০০?, C2 মোট ≥ ৩০০০? চারটি কলামের একটি (N, Y) অসম্ভব। তিনটি সম্ভব কলামের প্রতিটিতে একটি test চলেছে। Decision table coverage কত?
- ৭৫%
- ৫০%
- ১০০%
- ৬৬.৭%
(মাঝারি) অর্ডার-যন্ত্র: Placed –pay→ Paid –pack→ Packed –ship→ Shipped –deliver→ Delivered; Placed, Paid, Packed থেকে cancel → Cancelled; Cancelled –refund→ Refunded, শুধু টাকা দেওয়া থাকলে। সম্ভব 1-switch জোড়া কয়টি?
- ৭
- ৮
- ৬
- ৬৪
(মাঝারি) Decision (A or B) and not C-এর জন্য ন্যূনতম MC/DC set-এ কয়টি test?
- ৩
- ৬
- ৮
- ৪
(সহজ) ৭৪টি mutant-এর ৬৩টি killed, কোনোটি equivalent নয়। Mutation score?
- ১৪.৯%
- ৮৫.১%
- ৮৬.৩%
- ১০০%
(মাঝারি) তিনটি ঘর: পরিমাণ (১টি valid, ৩টি invalid দল), payment (৩টি valid, ১টি invalid) আর slot-এর ২টি valid ও ২টি invalid দল। Each-choice আর “একবারে একটি invalid” নিয়মে সর্বনিম্ন কয়টি test?
- ৪
- ৬
- ৯
- ১২
(মাঝারি) রিভিউর লেখা ছাঁটার পরে ১০–৫০০ Unicode code point হতে হবে। “ভালো চাল” লেখাটির কী হবে?
- প্রত্যাখ্যাত, কারণ ৮টি code point
- প্রত্যাখ্যাত, কারণ ৫টি অক্ষর
- গৃহীত, কারণ ২২টি byte
- গৃহীত, কারণ দুটি শব্দই যথেষ্ট
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব শব্দ এখানে একসাথে:
মনে রাখুন
- আগে coverage item, পরে test: partition, সীমা, কলাম, transition, জোড়া বা condition-এর তালিকা ও সংখ্যা লিখে তবে test বাছুন; coverage-এর হর এখান থেকেই।
- রীতি ঘোষণা করুন: ISTQB-আক্ষরিক না শুধু বৈধ কিনারা, Jorgensen না ISTQB, decision না condition স্তরের V(G); একই প্রশ্নে রীতি বদলালে উত্তর বদলায়।
- লুকানো সীমা খুঁজুন: floor-এর ৩০১০, code point বনাম UTF-16, UTC বনাম ঢাকার সময়, stock-এর সাথে সরে যাওয়া সীমা।
- Guard আর constraint বাদ দিন, ভুলবেন না: অসম্ভব জোড়া হরে নেই, কিন্তু উল্টো দিকের negative test আলাদা করে রাখুন।
- Coverage চালানো মাপে, যাচাই নয়: ১০০% branch-এও
Trueতারা পার পায়; mutant আর black-box নকশা সেই ফাঁক ধরে।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- সফটওয়্যার টেস্টিং ও QA · কোর্স হোম৮২টি পর্বপুরো কোর্সের মানচিত্র আর ১৪টি মডিউল।
- পর্ব ০৮ · Boundary value analysisআবার পড়ুন২-মান আর ৩-মান রীতি, mutant দিয়ে তুলনা।
- পর্ব ০৯ · Decision table আর cause-effectআবার পড়ুনটেবিল ছোট করা আর requirement-এর বিরোধ ধরা।
- পর্ব ১৩ · White-box testingআবার পড়ুনcoverage.py দিয়ে সত্যিকারের branch রিপোর্ট আর MC/DC.
- পর্ব ৫৯ · Mutation testingআবার পড়ুনcosmic-ray-এর run আর survivor পড়ার কৌশল।
- সফটওয়্যার ইঞ্জিনিয়ারিং ও Git · পর্ব ৪৭ · Test design techniqueপাশের ট্র্যাকএকই কৌশলের সংক্ষিপ্ত পরিচয়।
- ডিসক্রিট ম্যাথ · পর্ব ৭৯ · Numerical অনুশীলনপাশের ট্র্যাকগণনা আর graph-এর হিসাবের গাণিতিক দিক।