এই পর্বে যা শিখবেন
- যেকোনো configuration-এর সব মিশ্রণ, মোট মান-জোড়া আর pairwise-এর নিম্নসীমা হাতে গোনা
- একটি সহজ greedy pairwise generator কীভাবে সারি বাছে, আর pair coverage কীভাবে যাচাই করতে হয়
- Orthogonal array আর covering array-র পার্থক্য, আর কোথায় কোনটি খাটে
- Constraint আর অবৈধ মান model-এ লেখা; PICT দিয়ে আসল suite বানানো আর মিলিয়ে দেখা
- Pairwise suite থেকে আসল unittest, একটি দুই-মানের defect ধরা আর একটি তিন-মানের defect ফসকানো দেখা
১ · মিশ্রণের বিস্ফোরণ — checkout-এর ২১৬টি পথ
বাজারঘরের checkout পাতায় ক্রেতা পাঁচটি জিনিস বাছেন বা তাঁর পরিবেশ থেকে আসে: কোন জেলায় পণ্য যাবে, টাকা কীভাবে দেবেন (cash, mobile-wallet, card), কোন সময়ে delivery চান (সকাল, দুপুর, সন্ধ্যা), কোন device থেকে কিনছেন, আর পাতা কোন ভাষায় দেখছেন। প্রতিটি আলাদাভাবে test করা সহজ। কিন্তু defect প্রায়ই লুকিয়ে থাকে দুটি জিনিসের মিলনে: mobile-wallet-এর পাতা tablet-এ খুলতেই আটকে যায়, অথচ phone-এ ঠিক চলে; বা ইংরেজি পাতায় card-এর ফর্মে delivery charge ভুল দেখায়, বাংলায় নয়।
সব মিশ্রণ test করলে কত test? গুণের নিয়মে (ডিসক্রিট ম্যাথ কোর্সের পর্ব ৩১): ৬৪ জেলা × ৩ payment × ৩ slot × ৪ device × ২ ভাষা = ৪,৬০৮টি। একটি manual test-এ পাঁচ মিনিট লাগলে প্রায় ৩৮৪ ঘণ্টা। প্রতিটি নতুন parameter পুরো সংখ্যাকে আবার গুণ করে; এই দ্রুত বেড়ে চলাকে বলে combinatorial explosion. Exhaustive testing যে প্রায় কখনো সম্ভব নয়, testing-এর সাত নীতির সেই কথা (পর্ব ০৩) এখানে সংখ্যায় দেখা যাচ্ছে।
প্রথম ধাপটি আসলে পুরোনো কৌশল: equivalence partitioning (পর্ব ০৭)। Delivery charge-এর নিয়মে জেলার ভূমিকা একটাই: ঢাকার ভেতরে না বাইরে। তবু আমরা তিনটি প্রতিনিধি রাখি: ঢাকা, চট্টগ্রাম (কোডে Ctg) আর রাজশাহী, যাতে “বাইরে” দলের দুটি ভিন্ন জেলা থাকে। এখন সব মিশ্রণ ৩ × ৩ × ৩ × ৪ × ২ = ২১৬টি। কমেছে, তবু অনেক। এই পর্বের প্রশ্ন: ২১৬-এর বদলে মাত্র এক ডজনের মতো test দিয়ে কী নিশ্চয়তা পাওয়া যায়?
বিয়েবাড়িতে আত্মীয়দের খাওয়ানো হবে কয়েক ব্যাচে। মুরুব্বিদের ইচ্ছা: যেকোনো দুই পরিবারের অন্তত একজন করে মানুষ অন্তত একবার এক টেবিলে বসুক, যাতে সবার সাথে সবার আলাপ হয়। প্রতিটি সম্ভাব্য টেবিল-সাজানো চেষ্টা করার দরকার নেই; চালাক সাজানোয় অল্প কয়েক ব্যাচেই প্রতিটি “জোড়া”র দেখা হয়ে যায়। Pairwise testing ঠিক এই কাজটি করে parameter-এর মান নিয়ে।
Delivery charge: ঢাকার ভেতরে ৬০ টাকা, বাইরে ১২০ টাকা; ঢাকার ভেতরে অর্ডার ২০০০ টাকা বা বেশি হলে ফ্রি। Coupon: অর্ডার ১০০০ টাকার বেশি হলে ১০% ছাড়, সর্বোচ্চ ৩০০ টাকা; ছাড় শুধু পণ্যের দামে। Checkout-এর ঘর: জেলা, payment method (cash, mobile-wallet, card), delivery slot. Mobile-wallet ধাপটি সবসময় একটি mock, আসল লেনদেন নয়। এই পর্বে অর্ডারের মোট টাকা ১৫০০ টাকায় স্থির রাখা হলো, যাতে শুধু configuration-এর প্রভাব দেখা যায়; টাকার সীমা BVA-র কাজ (পর্ব ০৮)।
১৯৮৫ সালে Robert Mandl Communications of the ACM-এ Ada compiler test করার জন্য orthogonal Latin square ব্যবহারের প্রস্তাব দেন; software testing-এ মিশ্রণ-নকশার এটি প্রথম দিকের পরিচিত লেখা। পরিসংখ্যানের পরীক্ষা-নকশায় orthogonal array শিল্পে জনপ্রিয় করেন Genichi Taguchi. ১৯৯৭ সালে David Cohen, Siddhartha Dalal, Michael Fredman ও Gardner Patton IEEE Transactions on Software Engineering-এ AETG নামের greedy generator প্রকাশ করেন। আর ২০০০-এর দশকে NIST-এর D. Richard Kuhn ও সহকর্মীরা বাস্তব bug report বিশ্লেষণ করে দেখান, কতগুলো parameter মিললে ভুল ঘটে (§৭-এ বিস্তারিত)।
সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৪৭-এ সমান আকারের চারটি parameter-এ ৮১ থেকে ৯-এ নামার একটি উদাহরণ সংক্ষেপে দেখেছেন। এখানে আরও গভীরে যাব: অসমান parameter, নিম্নসীমার হিসাব, constraint, অবৈধ মান, 3-way, coverage যাচাই, আসল tool আর আসল test.
২ · Pairwise-এর ভাষা — parameter, মান-জোড়া আর নিম্নসীমা
প্রথমে কয়েকটি শব্দ, ISTQB-এর syllabus আর ISO/IEC/IEEE 29119-4-এর ধারণা আমাদের ভাষায়:
- Parameter (factor): যা বদলে test করা হয়, যেমন জেলা বা device. প্রতিটি parameter-এর কয়েকটি বাছাই করা মান (value) থাকে।
- t-way মিশ্রণ: যেকোনো t-টি parameter থেকে একটি করে মান। t = 2 হলে একটি মান-জোড়া, যেমন (wallet, tablet).
- Pairwise testing: এমন test suite, যাতে প্রতিটি সম্ভবপর মান-জোড়া অন্তত একটি test-এ আসে। t যেকোনো হলে নাম combinatorial testing.
- Pair coverage: suite-এ আসা সম্ভবপর জোড়া ÷ মোট সম্ভবপর জোড়া, শতাংশে। এখানে প্রতিটি মান-জোড়া একটি coverage item.
কেন এত কম test-এ হয়? কারণ একটি test অনেক জোড়া একসাথে ঢাকে। পাঁচ parameter-এর একটি সারিতে parameter-জোড়া C(5, 2) = ১০টি, তাই একটি test একবারে ১০টি মান-জোড়া ঢাকে। আর একটি নিম্নসীমা সবসময় খাটে: সবচেয়ে বড় দুই parameter-এর মান-সংখ্যার গুণফলের চেয়ে কম test হতে পারে না, কারণ ওই দুইয়ের প্রতিটি জোড়া আলাদা সারিতে লাগে। Checkout-এ device ৪ আর পরের বড়টি ৩, তাই অন্তত ৪ × ৩ = ১২টি test. ছোট একটি উদাহরণে জোড়াগুলো হাতে গুনি:
| ধাপ | |
| জোড়া | |
| গোনা |
- সব মিশ্রণ। তিনটি parameter: payment-এর ৩টি মান, slot-এর ২টি (দিন, সন্ধ্যা), ভাষার ২টি। সব মিশ্রণ ৩ × ২ × ২ = ১২টি সারি। এগুলোই exhaustive suite.
- প্রথম parameter-জোড়া: payment × slot. প্রতিটি payment-এর সাথে প্রতিটি slot: ৩ × ২ = ৬টি মান-জোড়া। Suite-এর কোথাও “card আর সন্ধ্যা” একসাথে না থাকলে এই জোড়াটি অপরীক্ষিত।
- দ্বিতীয় জোড়া: payment × lang. আবার ৩ × ২ = ৬টি: cash-বাংলা, cash-ইংরেজি, এভাবে।
- তৃতীয় জোড়া: slot × lang. ২ × ২ = ৪টি। তিন parameter থেকে parameter-জোড়া C(3, 2) = ৩টি, তাই এখানেই তালিকা শেষ।
- মোট আর নিম্নসীমা। ৬ + ৬ + ৪ = ১৬টি জোড়া ঢাকতে হবে। একটি সারি তিনটি জোড়া ঢাকে, তাই অন্তত ১৬ ÷ ৩, ওপরে গোল করে ৬টি সারি; আর payment × slot-এর ৬টি জোড়াও আলাদা সারি চায়। দুই যুক্তিতেই নিম্নসীমা ৬. পরের stepper দেখাবে ৬টিতেই হয়ে যায়: ১২-র অর্ধেক।
২১৬ থেকে ১৩ — কত test, আর জোড়া কোথায় ঢাকা হলো
Test counts for the checkout model, and which pairwise rows cover each payment × slot pair
৩ · Greedy generator — সারি বাছাই ধাপে ধাপে
সবচেয়ে সহজ পদ্ধতিটি একটি greedy algorithm: সব সম্ভাব্য সারির মধ্যে সেটি নিন, যা এখনো-না-ঢাকা জোড়া সবচেয়ে বেশি ঢাকে; সমান হলে তালিকার আগেরটি। জোড়া শেষ না হওয়া পর্যন্ত চালিয়ে যান। AETG থেকে PICT পর্যন্ত বাস্তব tool আরও চতুর কৌশল নেয় (যেমন সব সারি না দেখে কয়েকটি প্রার্থী বানানো), কিন্তু মূল ভাবনা এটাই। ছোট উদাহরণে চালাই; সারি পরীক্ষার ক্রম payment, তারপর slot, তারপর ভাষা:
| বাছা হলো | |
| নতুন জোড়া | |
| বাকি জোড়া |
- শুরু। কোনো সারি নেওয়া হয়নি, ১৬টি জোড়াই বাকি। প্রতিটি প্রার্থী সারি সর্বোচ্চ ৩টি নতুন জোড়া দিতে পারে।
- T1 = cash·day·bn. তালিকার প্রথম সারি, তিনটি জোড়াই নতুন (cash·day, cash·bn, day·bn). বাকি ১৩।
- T2 = cash·evening·en. পরের সারি cash·day·en-এ cash·day আগেই ঢাকা, লাভ মাত্র ২; cash·evening·bn-এও cash·bn পুরোনো। প্রথম যে সারি পুরো ৩ দেয়, সেটি cash·evening·en. বাকি ১০।
- T3 = wallet·day·en. wallet·day·bn-এ day·bn পুরোনো, তাই ২; wallet·day·en তিনটিই নতুন। বাকি ৭।
- T4 = wallet·evening·bn. wallet·evening, wallet·bn, evening·bn তিনটিই নতুন। বাকি ৪: card-এর চারটি জোড়া।
- T5 = card·day·bn. এখন কোনো সারিই ৩ দিতে পারে না, কারণ slot × lang-এর চারটি জোড়াই ঢাকা হয়ে গেছে। সর্বোচ্চ লাভ ২; সমান হলে প্রথমটি, card·day·bn. বাকি ২।
- T6 = card·evening·en. শেষ দুটি জোড়া card·evening আর card·en. মোট ৬টি সারি: §২-এর নিম্নসীমার সমান, ১২-র অর্ধেক। এবার সব জোড়া ঢাকা হলো কি না, কোডে আলাদা করে যাচাই করতে হবে।
এবার একই নিয়ম পুরো checkout model-এ। নিচের কোডটি সাধারণ: t বদলালে 3-way-ও বানায়, আর ok দিয়ে constraint নেয় (পরের অংশে কাজে লাগবে)। coverage ফাংশনটি generator-কে বিশ্বাস না করে আলাদাভাবে গোনে কতগুলো জোড়া আসলে suite-এ আছে। “চালান” চাপুন; প্রথমবার ব্রাউজারে Pyodide (ব্রাউজারের Python) নামতে কয়েক সেকেন্ড লাগে। এই পর্বের চারটি code block একই namespace ভাগ করে, তাই পরের block-গুলো এখানকার ফাংশন ব্যবহার করবে।
from itertools import combinations, product
F = {"district": ["Dhaka", "Ctg", "Rajshahi"],
"payment": ["cash", "wallet", "card"],
"slot": ["morning", "afternoon", "evening"],
"device": ["android", "iphone", "desktop", "tablet"],
"lang": ["bn", "en"]}
def combos_of(row, t=2): # the t-way value combinations in one row
return {tuple((i, row[i]) for i in c)
for c in combinations(range(len(row)), t)}
def greedy(F, t=2, ok=lambda r: True):
rows = [r for r in product(*F.values()) if ok(r)] # feasible rows
need = set().union(*(combos_of(r, t) for r in rows))
left, suite = set(need), []
while left: # take the row with most new combos
best = max(rows, key=lambda r: len(combos_of(r, t) & left))
left -= combos_of(best, t) # max() keeps the first row on a tie
suite.append(best)
return rows, need, suite
def coverage(suite, need, t=2): # covered / feasible combos, in %
got = set().union(*(combos_of(r, t) for r in suite)) & need
return 100 * len(got) / len(need)
rows, need, suite = greedy(F)
for n, r in enumerate(suite, 1):
print(f"P{n:02} " + " ".join(f"{v:<9}" for v in r).rstrip())
print("exhaustive rows :", len(rows))
print("pairs to cover :", len(need))
print("pairwise tests :", len(suite))
print(f"pair coverage : {coverage(suite, need):.0f}%")আসল আউটপুট (ব্রাউজারের Python):
P01 Dhaka cash morning android bn
P02 Dhaka wallet afternoon iphone en
P03 Ctg cash evening desktop en
P04 Ctg card afternoon tablet bn
P05 Rajshahi wallet morning desktop bn
P06 Rajshahi card evening android en
P07 Dhaka wallet evening tablet bn
P08 Ctg card morning iphone bn
P09 Rajshahi cash morning tablet en
P10 Dhaka card afternoon desktop bn
P11 Ctg wallet afternoon android bn
P12 Rajshahi cash afternoon iphone bn
P13 Dhaka cash evening iphone bn
exhaustive rows : 216
pairs to cover : 89
pairwise tests : 13
pair coverage : 100%
জোড়ার হিসাব মিলিয়ে নিন: দশটি parameter-জোড়ার গুণফলের যোগ: জেলা × payment ৯, জেলা × slot ৯, জেলা × device ১২, জেলা × ভাষা ৬, payment × slot ৯, payment × device ১২, payment × ভাষা ৬, slot × device ১২, slot × ভাষা ৬, device × ভাষা ৮; মোট ৮৯. Generator ১৩টি সারিতে সব ঢেকেছে, নিম্নসীমা ১২-র মাত্র এক বেশি। প্রথম চারটি সারি ১০টি করে নতুন জোড়া দেয়; পরের দিকে লাভ কমতে থাকে, আর শেষ সারি P13 আসে মাত্র একটি বাকি জোড়ার (cash·iphone) জন্য। এটি greedy-র চেনা স্বভাব: শুরুতে দ্রুত, শেষে খুঁটে খুঁটে।
শেষ লাইনের ১০০% generator-এর দাবি নয়; coverage suite-এর সারি থেকে নতুন করে জোড়া গুনে মিলিয়েছে। Tool-এর দেওয়া suite-ও এভাবে যাচাই করা উচিত (§৮-এ PICT-এর বেলায় করব)।
৪ · Orthogonal array আর covering array
Pairwise-এর ইতিহাস শুরু হয়েছিল একটি আরও কঠোর কাঠামো থেকে: orthogonal array. এর শর্ত, যেকোনো দুই কলামে প্রতিটি মান-জোড়া সমান সংখ্যকবার আসবে। সবচেয়ে পরিচিত উদাহরণ L9(34): ৯টি সারি, তিন-মানের চারটি কলাম। মান ০, ১, ২ ধরে নিলে চারটি কলাম হলো a, b, (a + b) mod 3 আর (a + 2b) mod 3:
| সারি | A | B | C = A+B | D = A+2B |
|---|---|---|---|---|
| 1 | 0 | 0 | 0 | 0 |
| 2 | 0 | 1 | 1 | 2 |
| 3 | 0 | 2 | 2 | 1 |
| 4 | 1 | 0 | 1 | 1 |
| 5 | 1 | 1 | 2 | 0 |
| 6 | 1 | 2 | 0 | 2 |
| 7 | 2 | 0 | 2 | 2 |
| 8 | 2 | 1 | 0 | 1 |
| 9 | 2 | 2 | 1 | 0 |
যেকোনো দুই কলাম বেছে দেখুন: নয়টি সম্ভাব্য জোড়া (০·০ থেকে ২·২) প্রতিটি ঠিক একবার আসে (scratch script-এ ছয়টি কলাম-জোড়াতেই মিলিয়ে দেখা)। C আর D কলাম দুটি আসলে দুটি পরস্পর orthogonal Latin square: A-কে সারি আর B-কে কলাম ধরে C-এর মান ৩ × ৩ ছকে বসালে প্রতিটি সারি-কলামে প্রতিটি অঙ্ক একবার। মডুলার গণনার নিয়ম ডিসক্রিট ম্যাথ কোর্সের পর্ব ২২-এ পাবেন।
সমস্যা হলো বাস্তবের parameter সমান আকারের হয় না। Checkout-এ তিনটি তিন-মানের, একটি চার-মানের আর একটি দুই-মানের parameter; এমন মিশ্র আকারের জন্য ছোট orthogonal array প্রায়ই নেই, আর জোর করে বানালে অনেক বাড়তি সারি লাগে। Testing-এর জন্য সমান সংখ্যকবার আসার শর্তটি দরকারও নেই; দরকার “অন্তত একবার”। এই ঢিলে শর্তের টেবিলকে বলে covering array. §৩-এর ১৩টি সারি একটি covering array: cash·morning দুবার আছে (P01, P09), wallet·morning একবার; কোনো ক্ষতি নেই।
Orthogonal array
প্রতিটি জোড়া সমান সংখ্যকবার। পরিসংখ্যানে প্রতিটি parameter-এর প্রভাব আলাদা করে মাপতে ভারসাম্য দরকার, তাই এই শর্ত। সমান আকারের parameter-এ চমৎকার, মিশ্র আকারে কঠিন।
উদাহরণ: L9(3⁴), L8(2⁷)Covering array
প্রতিটি জোড়া অন্তত একবার। ভুল খোঁজায় ভারসাম্য লাগে না, তাই সাধারণত কম সারি লাগে আর যেকোনো আকারে বানানো যায়। আজকের pairwise tool এটাই বানায়।
উদাহরণ: §৩-এর ১৩টি সারিCovering array কতটা ছোট হতে পারে, তার একটি সুন্দর উদাহরণ: দুই-মানের (হ্যাঁ/না) ১০টি parameter-এর সব মিশ্রণ ২10 = ১,০২৪টি, কিন্তু মাত্র ৬টি সারিতে সব জোড়া ঢাকা যায়। ছয় দৈর্ঘ্যের যেসব ০/১ কলামের প্রথম অঙ্ক ০ আর ঠিক তিনটি ১, এমন কলাম C(5, 3) = ১০টি; যেকোনো দুটি নিলে চারটি জোড়া (০০, ০১, ১০, ১১) সবই আসে। (Scratch script-এ যাচাই করা।) Parameter যত বাড়ে, pairwise suite বাড়ে খুব ধীরে, মোটামুটি parameter-সংখ্যার লগারিদমের হারে; এটাই কৌশলটির শক্তি।
৫ · Constraint আর each-choice — অসম্ভব মিশ্রণ বাদ, দুর্বল suite চেনা
বাজারঘরের একটি ব্যবসার নিয়ম: ঢাকার বাইরে সন্ধ্যার delivery slot নেই। §৩-এর suite এই নিয়ম জানে না, তাই এর P03 (Ctg, সন্ধ্যা) আর P06 (Rajshahi, সন্ধ্যা) সারিগুলো আসলে চালানোই যায় না: checkout পাতা ওই slot দেখাবেই না। এমন সারিতে test হয় fail করে বিভ্রান্তি ছড়ায়, নয়তো tester হাতে বদলাতে গিয়ে অন্য জোড়া হারিয়ে ফেলেন। সমাধান: নিয়মটি generator-কে জানানো, যাকে বলে constraint.
| ধাপ | |
| দেখা গেল |
- নিয়মটি শর্তে লেখা। “জেলা ঢাকা না হলে slot সন্ধ্যা হতে পারবে না।” যুক্তির ভাষায়: district ≠ Dhaka হলে slot ≠ evening. কোডে এটি
ok(row)ফাংশন, PICT-এ একটিIF … THENলাইন। - সম্ভবপর সারি গোনা। নিয়ম ভাঙে এমন সারি: ঢাকার বাইরের ২ জেলা × ৩ payment × ১ slot (সন্ধ্যা) × ৪ device × ২ ভাষা = ৪৮টি। বাকি ২১৬ − ৪৮ = ১৬৮টি সারি চালানো সম্ভব।
- অসম্ভব জোড়া বাদ। দুটি মান-জোড়া এখন কোনো বৈধ সারিতেই আসতে পারে না: Ctg·evening আর Rajshahi·evening. এগুলো coverage-এর হিসাব থেকেও বাদ, নইলে ১০০% কখনো হবে না। ঢাকতে হবে ৮৯ − ২ = ৮৭টি।
- একটি প্রার্থী সারি পরীক্ষা। Constraint ছাড়া generator-এর P03 ছিল Ctg·cash·evening·desktop·en. নিয়মে বসালে জেলা ঢাকা নয় আর slot সন্ধ্যা, তাই সারিটি অবৈধ; generator একে প্রার্থী তালিকাতেই রাখে না।
- ফল। Constraint মেনে greedy ১৪টি test দেয় (আগের চেয়ে একটি বেশি), ৮৭টি জোড়ার সবই ঢাকা, নিয়ম ভাঙা সারি শূন্য। Constraint সাধারণত suite একটু বাড়ায়, কারণ বাছাইয়ের স্বাধীনতা কমে।
কোডে একই কাজ, আর সাথে একটি তুলনা: each-choice suite (প্রতিটি মান অন্তত একবার, পর্ব ০৭-এ দেখা) কতটা জোড়া ঢাকে। এই block আগের block-এর ফাংশন ব্যবহার করে; আগেরটি না চালালে নিজে থেকে আগে সেটি চলবে।
# Each-choice: every value at least once (row k takes value k mod size)
each = [tuple(v[k % len(v)] for v in F.values()) for k in range(4)]
print(f"each-choice {len(each):>2} tests, pair coverage "
f"{coverage(each, need):.1f}%")
gap = need - set().union(*(combos_of(r) for r in each))
print(" pairs never tested:", len(gap), "of", len(need))
# Constraint: outside Dhaka there is no evening delivery slot
def ok(r):
return r[0] == "Dhaka" or r[2] != "evening"
rows_c, need_c, suite_c = greedy(F, ok=ok)
print(f"constrained rows {len(rows_c)}, pairs {len(need_c)}, "
f"tests {len(suite_c)}, pair coverage "
f"{coverage(suite_c, need_c):.0f}%")
print(" infeasible pairs:", sorted(need - need_c))
bad = [r for r in suite if not ok(r)]
print(" unconstrained suite rows that break the rule:", len(bad))
for r in bad:
print(" ", r)আসল আউটপুট (ব্রাউজারের Python):
each-choice 4 tests, pair coverage 41.6%
pairs never tested: 52 of 89
constrained rows 168, pairs 87, tests 14, pair coverage 100%
infeasible pairs: [((0, 'Ctg'), (2, 'evening')), ((0, 'Rajshahi'), (2, 'evening'))]
unconstrained suite rows that break the rule: 2
('Ctg', 'cash', 'evening', 'desktop', 'en')
('Rajshahi', 'card', 'evening', 'android', 'en')
Each-choice: ৪টি test-এ (সবচেয়ে বড় parameter device-এর ৪টি মান) প্রতিটি মান অন্তত একবার এসেছে, তবু ৮৯টি জোড়ার মাত্র ৩৭টি, অর্থাৎ ৪১.৬%. বাকি ৫২টি জোড়া কখনো একসাথে test হয় না। Each-choice মানের উপস্থিতি নিশ্চিত করে, মিলন নয়।
মাঝামাঝি আরেকটি পরিচিত পদ্ধতি base-choice: একটি সাধারণ ভিত্তি সারি (Dhaka, cash, morning, android, bn) রেখে প্রতিবার একটি parameter-এর একটি মান বদলানো। এতে test লাগে ১ + (২ + ২ + ২ + ৩ + ১) = ১১টি, আর একই checker-এ (scratch-এ চালানো) জোড়া ঢাকে ৮৯-এর ৫০টি, অর্থাৎ ৫৬.২%. প্রায় pairwise-এর সমান সংখ্যক test, কিন্তু অর্ধেকের সামান্য বেশি জোড়া; কারণ প্রতিটি সারিতে মাত্র একটি মান ভিত্তি থেকে সরে, তাই অ-ভিত্তি দুটি মান কখনো একসাথে আসে না।
Constraint: সম্ভবপর সারি ১৬৮, জোড়া ৮৭, test ১৪, coverage ১০০%; stepper-এর প্রতিটি সংখ্যা এখানে মিলে গেল। শেষ তিন লাইন দেখায় constraint ছাড়া বানানো suite-এর দুটি সারি নিয়ম ভাঙে। Tool-এ constraint লিখতে ভুলে গেলে ঠিক এমন সারি আসে।
Constraint দুই রকম, আর গুলিয়ে ফেলা বিপজ্জনক। অসম্ভব মিশ্রণ (UI-তে বাছাই করাই যায় না) বাদ দেওয়া ঠিক। কিন্তু অবৈধ মিশ্রণ (বাছাই করা যায়, আর software-এর তা প্রত্যাখ্যান করার কথা) বাদ দিলে ঠিক সেই test হারায় যা যাচাই করে প্রত্যাখ্যানটি হচ্ছে কি না। যেমন API সরাসরি ডেকে কেউ Rajshahi·evening পাঠালে server কী করে? সেটি একটি আলাদা negative test, যা pairwise suite-এর বাইরে লিখতে হয়।
৬ · Pairwise টেবিল থেকে আসল unittest
Manual tester-এর হাতে suite-টি একটি টেবিল। প্রতিটি সারির expected result আসে requirement থেকে: মোট ১৫০০ টাকা, তাই ঢাকায় ৬০, বাইরে ১২০; বাকি চারটি parameter charge বদলানোর কথা নয়, কিন্তু checkout-টি সফলভাবে শেষ হওয়ার কথা। Pairwise নিজে কোনো expected দেয় না; সেটি সবসময় আপনার কাজ।
| ID | District · payment · slot · device · lang | Expected fee | নতুন জোড়া |
|---|---|---|---|
| C01 | Dhaka · cash · morning · android · bn | 60 | 10 |
| C02 | Dhaka · wallet · afternoon · iphone · en | 60 | 10 |
| C03 | Ctg · card · morning · desktop · en | 120 | 10 |
| C04 | Rajshahi · card · afternoon · tablet · bn | 120 | 10 |
| C05 | Dhaka · cash · evening · tablet · en | 60 | 8 |
| C06 | Dhaka · wallet · evening · desktop · bn | 60 | 7 |
| C07 | Ctg · cash · afternoon · iphone · bn | 120 | 7 |
| C08 | Rajshahi · wallet · morning · android · en | 120 | 7 |
| C09 | Dhaka · card · evening · android · bn | 60 | 4 |
| C10 | Ctg · wallet · morning · tablet · bn | 120 | 4 |
| C11 | Rajshahi · cash · afternoon · desktop · bn | 120 | 4 |
| C12 | Rajshahi · card · morning · iphone · bn | 120 | 3 |
| C13 | Ctg · cash · afternoon · android · bn | 120 | 2 |
| C14 | Dhaka · cash · evening · iphone · bn | 60 | 1 |
“নতুন জোড়া” কলামের যোগফল ৮৭: প্রতিটি জোড়া প্রথম যে সারিতে ঢাকা পড়েছে, সেখানে গোনা। Automation engineer টেবিলটিকে সরাসরি unittest-এ বসান; self.subTest প্রতিটি সারিকে আলাদা subtest হিসেবে চালায়। নিচের place_order-এ দুটি seeded defect ইচ্ছা করে বসানো: একটি দুই parameter-এর মিলনে (wallet আর tablet), আরেকটি তিনটির মিলনে (card, iPhone আর ইংরেজি)। দুটিই interaction fault: কোনো একটি মান একা ভুল ঘটায় না। চালানোর আগে অনুমান করুন কোনটি ধরা পড়বে।
import sys, unittest
def place_order(district, payment, slot, device, lang, total=1500):
"""Bazarghar checkout (wallet step is a MOCK). Returns delivery fee."""
if payment == "wallet" and device == "tablet":
raise RuntimeError("wallet mock: redirect lost") # seeded 2-way
if (payment, device, lang) == ("card", "iphone", "en"):
return 0 # seeded 3-way
if district == "Dhaka":
return 0 if total >= 2000 else 60
return 120
def expected_fee(district, total=1500): # from the written rule
return (0 if total >= 2000 else 60) if district == "Dhaka" else 120
class CheckoutPairwise(unittest.TestCase):
ROWS = suite_c # 14 constrained pairwise rows
def test_rows(self):
for n, row in enumerate(self.ROWS, 1):
with self.subTest(f"C{n:02}", row=" ".join(row)):
self.assertEqual(place_order(*row), expected_fee(row[0]))
res = unittest.TextTestRunner(stream=sys.stdout, verbosity=2).run(
unittest.TestLoader().loadTestsFromTestCase(CheckoutPairwise))
print("errors:", len(res.errors), "failures:", len(res.failures))
print("rows with card+iphone+en:",
sum((r[1], r[3], r[4]) == ("card", "iphone", "en") for r in suite_c))আসল আউটপুট (ব্রাউজারের Python, traceback-এর মাঝের লাইন ছাঁটা):
test_rows (__main__.CheckoutPairwise.test_rows) ...
test_rows (__main__.CheckoutPairwise.test_rows) [C10] (row='Ctg wallet morning tablet bn') ... ERROR
======================================================================
ERROR: test_rows (__main__.CheckoutPairwise.test_rows) [C10] (row='Ctg wallet morning tablet bn')
----------------------------------------------------------------------
Traceback (most recent call last):
…
RuntimeError: wallet mock: redirect lost
----------------------------------------------------------------------
Ran 1 test in 0.002s
FAILED (errors=1)
errors: 1 failures: 0
rows with card+iphone+en: 0
দুই-মানের defect ধরা পড়ল: ১৪টি subtest-এর মধ্যে শুধু C10 লাল, আর সেটি ERROR, FAIL নয়: assertion-এ পৌঁছানোর আগেই কোড exception ছুড়েছে। Wallet আর tablet একসাথে আছে শুধু C10-এ; pairwise-এর চুক্তি অনুযায়ী এই জোড়া কোথাও না কোথাও আসতেই হতো, তাই এমন যেকোনো দুই-মানের defect এই suite ধরবেই। Bug report-এ লিখবেন: “mobile-wallet দিয়ে tablet থেকে checkout করলে wallet-এর mock পাতা থেকে ফেরার পথ হারায়; অন্য device-এ wallet, আর tablet-এ অন্য payment ঠিক চলে।” শেষের তথ্যটি অন্য সবুজ সারিগুলো থেকে আসে (C02, C06, C08-এ wallet; C04, C05-এ tablet).
তিন-মানের defect ফসকাল: শেষ লাইন বলছে suite-এর কোনো সারিতে card, iPhone আর ইংরেজি একসাথে নেই। জোড়াগুলো আলাদাভাবে আছে (card·iphone C12-এ, card·en C03-এ, iphone·en C02-এ), কিন্তু তিনটি একসাথে নেই। তাই ভুলটি কোনো test চালায়ই না, আর suite “প্রায় সবুজ” দেখায়। পরের অংশে এর প্রতিকার।
৭ · 2-way-এর বাইরে — t = 3, আর প্রমাণ কী বলে
Pairwise একটি অনুমানের ওপর দাঁড়িয়ে: বেশিরভাগ failure একটি parameter-এর মানে, বা বড়জোর দুটির মিলনে ঘটে। এটি BVA-র single-fault assumption-এর একটু ঢিলে রূপ। অনুমানটি কতটা ঠিক, তা নিয়ে সবচেয়ে বেশি উদ্ধৃত কাজ NIST-এর D. Richard Kuhn, Dolores Wallace ও সহকর্মীদের। ২০০৪ সালে IEEE Transactions on Software Engineering-এ প্রকাশিত “Software Fault Interactions and Implications for Software Testing” প্রবন্ধে তাঁরা কয়েকটি ক্ষেত্রের (চিকিৎসা যন্ত্র, browser, server, database ইত্যাদি) bug report বিশ্লেষণ করেন। প্রবন্ধে যতদূর জানা যায়, তাঁদের নমুনায় বেশিরভাগ ভুল একটি বা দুটি parameter-এর মানে ঘটেছিল, মিলনের মাত্রা বাড়লে ভুলের অনুপাত দ্রুত কমেছিল, আর বিশ্লেষণ করা সব ভুল ছয় বা তার কম parameter-এর মিলনে ধরা পড়েছিল। শতাংশ ক্ষেত্রভেদে আলাদা ছিল; এটি শক্ত ইঙ্গিত, সার্বজনীন নিয়ম নয়।
যেখানে ঝুঁকি বেশি, সেখানে t = 3 বা তারও বেশি নেওয়া হয়। একই generator t=3 দিয়ে চালাই, আর একই test-কে নতুন suite দিই:
import io
rows3, need3, suite3 = greedy(F, t=3, ok=ok)
print(f"3-way: {len(need3)} triples, {len(suite3)} tests "
f"(exhaustive {len(rows_c)})")
print(f"triple coverage of the {len(suite_c)} pairwise tests: "
f"{coverage(suite_c, need3, t=3):.1f}%")
CheckoutPairwise.ROWS = suite3 # same test, stronger suite
res = unittest.TextTestRunner(stream=io.StringIO()).run(
unittest.TestLoader().loadTestsFromTestCase(CheckoutPairwise))
for sub, tb in res.errors + res.failures: # one line per red subtest
print(sub.params["row"], "->", tb.strip().splitlines()[-1])
print("red subtests:", len(res.errors) + len(res.failures))আসল আউটপুট (ব্রাউজারের Python):
3-way: 243 triples, 46 tests (exhaustive 168)
triple coverage of the 14 pairwise tests: 51.9%
Dhaka wallet afternoon tablet bn -> RuntimeError: wallet mock: redirect lost
Dhaka wallet evening tablet en -> RuntimeError: wallet mock: redirect lost
Ctg wallet morning tablet bn -> RuntimeError: wallet mock: redirect lost
Rajshahi wallet morning tablet bn -> RuntimeError: wallet mock: redirect lost
Rajshahi card morning iphone en -> AssertionError: 0 != 120
Ctg card afternoon iphone en -> AssertionError: 0 != 120
তিন-মানের সম্ভবপর মিশ্রণ ২৪৩টি; greedy ৪৬টি test-এ সব ঢেকেছে। Constraint মানা সব মিশ্রণ ১৬৮টি, তাই 3-way suite পুরোটার চেয়ে কম, কিন্তু pairwise-এর তিন গুণেরও বেশি। ১৪টি pairwise test নিজে থেকেই ২৪৩টি triple-এর ৫১.৯% (১২৬টি) ঢেকে ফেলেছিল; card·iphone·en পড়েছিল বাকি অর্ধেকে।
3-way suite দিয়ে এবার দুটি defect-ই ধরা পড়ল: wallet·tablet চারটি সারিতে, আর card·iphone·en দুটি সারিতে, যেখানে কোড ঢাকার বাইরেও charge 0 দিচ্ছে (expected 120). stream=io.StringIO() দিয়ে runner-এর লম্বা traceback চুপ রাখা হয়েছে, আর প্রতিটি লাল subtest-এর শুধু শেষ লাইন ছাপা হয়েছে। সাধারণ শিক্ষা: t এক বাড়ালে test কয়েক গুণ বাড়ে, তাই 3-way রাখুন ঝুঁকিপূর্ণ অংশে (টাকা, নিরাপত্তা), পুরো system-এ নয়।
৮ · সত্যিকারের run — PICT দিয়ে একই model
নিজের generator বোঝার জন্য; কাজের জন্য প্রস্তুত tool আছে। PICT (Pairwise Independent Combinatorial Testing) Microsoft-এর তৈরি একটি command-line tool; Jacek Czerwonka ২০০৬ সালের একটি প্রবন্ধে (“Pairwise Testing in Real World”) এর বাস্তব অভিজ্ঞতা লিখেছিলেন, আর পরে এটি GitHub-এ MIT লাইসেন্সে উন্মুক্ত হয়। Windows-এর জন্য একটি pict.exe release-এ পাওয়া যায়, অন্য OS-এ source থেকে build করতে হয়। নিচের সব আউটপুট আমাদের scratch ফোল্ডারে PICT 3.7.4 (GitHub release v3.7.4) চালিয়ে পাওয়া; ফোল্ডারের নাম নিরপেক্ষ করা হয়েছে, আর আউটপুটের tab-কে space দিয়ে সাজানো হয়েছে।
PICT-এর model একটি সাধারণ text ফাইল: প্রতি লাইনে একটি parameter আর তার মান, শেষে constraint:
District: Dhaka, Chattogram, Rajshahi
Payment: Cash, Wallet, Card
Slot: Morning, Afternoon, Evening
Device: Android, iPhone, Desktop, Tablet
Language: Bangla, English
IF [District] <> "Dhaka" THEN [Slot] <> "Evening";Run ১: constraint-সহ pairwise suite
$ cd ~/bazarghar-qa/pairwise
$ pict checkout_c.txt
District Payment Slot Device Language
Chattogram Cash Morning Tablet Bangla
Dhaka Wallet Evening Tablet English
Rajshahi Wallet Afternoon Android Bangla
Rajshahi Card Morning Desktop English
Chattogram Cash Afternoon iPhone English
Dhaka Cash Evening Android English
Dhaka Card Afternoon Tablet Bangla
Rajshahi Wallet Morning iPhone Bangla
Dhaka Cash Evening Desktop Bangla
Rajshahi Cash Morning Tablet English
Chattogram Wallet Afternoon Desktop English
Dhaka Card Evening iPhone Bangla
Chattogram Card Morning Android English
Dhaka Cash Morning Android Bangla
১৪টি সারি, আমাদের greedy-র মতোই সংখ্যা, কিন্তু সারিগুলো আলাদা: একই model-এর অনেক বৈধ pairwise suite থাকে। এখানেও card·iPhone·English একসাথে নেই, তাই §৬-এর তিন-মানের defect এই suite-ও ফসকাত।
Run ২: পরিসংখ্যান আর 3-way
$ pict checkout.txt /s
Combinations: 89
Generated tests:15
Generation time:0:00:00
$ pict checkout_c.txt /s
Combinations: 87
Generated tests:14
Generation time:0:00:00
$ pict checkout_c.txt /o:3 /s
Combinations: 243
Generated tests:45
Generation time:0:00:00
/s model-এর পরিসংখ্যান দেখায়। “Combinations” আমাদের হিসাবের সাথে হুবহু মেলে: constraint ছাড়া ৮৯, সাথে ৮৭, আর 3-way-তে ২৪৩. Test-এর সংখ্যায় সামান্য পার্থক্য: constraint ছাড়া PICT ১৫ (আমাদের greedy ১৩), 3-way-তে PICT ৪৫ (আমাদের ৪৬)। দুটিই heuristic; কোনোটিই সবসময় ন্যূনতম দেয় না। /o:3 মানে order বা t = 3. PICT-এর help-এ আরও কয়েকটি option আছে, যেমন /e:file দিয়ে আগে থেকে ঠিক করা সারি (seeding) আর /r দিয়ে এলোমেলো ক্রম; ব্যবহারের আগে নিজের version-এর help দেখে নিন।
Run ৩: tool-কে বিশ্বাস নয়, যাচাই
PICT-এর আউটপুট ফাইলে সেভ করে আমাদের ছোট checker verify_pict.py (Python 3.14, শুধু standard library) চালানো হলো। এটি §৩-এর coverage-এর মতো সব সম্ভবপর জোড়া গোনে আর constraint ভাঙা সারি খোঁজে:
$ pict checkout_c.txt > with_rule.txt
$ pict checkout.txt > no_rule.txt
$ python verify_pict.py with_rule.txt
tests: 14 | feasible pairs: 87
covered: 87 (100%)
rows breaking the constraint: 0
$ python verify_pict.py no_rule.txt
tests: 15 | feasible pairs: 87
covered: 87 (100%)
rows breaking the constraint: 4
Constraint-সহ suite নিখুঁত। Constraint ছাড়া suite-ও সব সম্ভবপর জোড়া ঢাকে, কিন্তু ১৫টির ৪টি সারি চালানোই যায় না (ঢাকার বাইরে সন্ধ্যা)। এই চারটি বাদ দিলে কিছু জোড়া হারিয়ে যাবে; তাই নিয়ম model-এ লিখে নতুন করে বানানোই ঠিক পথ।
Run ৪: অবৈধ মান — এক সারিতে একটিই
পর্ব ০৭-এর নিয়ম মনে আছে? এক test-এ একটির বেশি অবৈধ মান দিলে একটি প্রত্যাখ্যান আরেকটিকে ঢেকে দেয়। PICT-এ অবৈধ partition-এর প্রতিনিধির আগে ~ বসালে tool এই নিয়ম নিজে মানে:
Payment: Cash, Wallet, Card
Phone: 01712345678, 01312345678, ~0171234567, ~01212345678
Amount: 500, 1001, 3001, ~0$ pict phone_neg.txt
Payment Phone Amount
Card 01712345678 500
Wallet 01712345678 3001
… (আরও ৭টি বৈধ সারি)
Cash ~0171234567 3001
Wallet ~0171234567 1001
Wallet 01312345678 ~0
Wallet ~01212345678 500
Cash 01712345678 ~0
Card ~0171234567 500
Cash ~01212345678 3001
Card 01312345678 ~0
Card ~01212345678 1001
মোট ১৮টি সারি: ৯টিতে সব মান বৈধ (বৈধ মানের ২১টি জোড়া সেগুলোতেই ঢাকা), আর ৯টিতে ঠিক একটি করে ~ মান; কোনো সারিতে দুটি অবৈধ মান নেই (scratch script-এ গুনে দেখা)। Phone number-এর নিয়ম কাল্পনিক: ১১ অঙ্ক, শুরু 01, তৃতীয় অঙ্ক 3–9; তাই ১০ অঙ্কের 0171234567 আর তৃতীয় অঙ্ক 2-এর নম্বর অবৈধ।
৯ · কাজের ধারা, ফাঁদ আর কখন pairwise নয়
ছয় ধাপের কাজের ধারা
- Requirement আর পরিবেশ থেকে parameter চিহ্নিত করুন: কোন জিনিস বদলালে আচরণ বদলাতে পারে।
- প্রতিটি parameter-এর মান বাছুন EP আর BVA দিয়ে (৬৪ জেলা নয়, তিনটি প্রতিনিধি)। এই ধাপই সবচেয়ে বড় সিদ্ধান্ত।
- Constraint লিখুন: কোন মিশ্রণ অসম্ভব; আর অবৈধ মান আলাদা চিহ্ন দিন।
- Tool দিয়ে suite বানান; ঝুঁকিপূর্ণ অংশে t বাড়ান, জরুরি সারি seed করুন।
- Suite যাচাই করুন: coverage % আর constraint ভাঙা সারি, tool-এর দাবি ছাড়াই।
- প্রতিটি সারির expected result requirement থেকে লিখুন, চালান, আর লাল সারির জোড়াগুলো অন্য সবুজ সারির সাথে মিলিয়ে সন্দেহভাজন মিলন আলাদা করুন।
সাধারণ ফাঁদ
- মান বাছাই খারাপ: network-এর মান থেকে “offline” বাদ পড়লে কোনো generator তা ফেরাবে না। Pairwise মান মেশায়, মান খোঁজে না।
- সব কিছুকে parameter বানানো: ৬৪ জেলাকে ৬৪টি মান রাখলে নিম্নসীমাই ৬৪ × ৪ = ২৫৬টি test. আগে partition, পরে pairwise.
- যুক্তির নিয়মে pairwise: ঢাকা আর ২০০০ টাকা মিলে charge ফ্রি, এমন নির্দিষ্ট শর্তের মিশ্রণ decision table-এর কাজ (পর্ব ০৯); pairwise ওই নির্দিষ্ট সারিটির নিশ্চয়তা দেয় না।
- ক্রম আর অবস্থা: “আগে cancel, তারপর refund”-এর মতো ঘটনার ক্রম configuration নয়; তার জন্য state transition testing (পর্ব ১০)।
- Model বদলালে সারি বদলায়: একটি মান যোগ করলে পুরো suite নতুন হতে পারে, ফলে পুরোনো bug-এর সারি হারায়। জরুরি সারি seed করে রাখুন, আর regression-এর জন্য সারি-তালিকা সংস্করণসহ সংরক্ষণ করুন।
- “১০০% pair coverage” মানে “সব ঠিক” নয়: এটি শুধু বলে model-এর জোড়াগুলো চালানো হয়েছে; তিন-মানের মিলন, model-এর বাইরের মান আর ভুল expected এর আওতার বাইরে।
কোথায় pairwise সবচেয়ে কাজের: configuration testing (browser × OS × ভাষা × screen, পর্ব ৪২-এ browser matrix আর পর্ব ৬৯-এ mobile device), অনেক setting-ওয়ালা ফর্ম বা API option, আর feature flag-এর মিশ্রণ। Data-driven automation-এ (পর্ব ৪৫) pairwise টেবিলটিই test data ফাইল হয়ে যায়।
আরও গভীরে: নির্দিষ্ট parameter আর মানের জন্য সবচেয়ে ছোট covering array খোঁজা সাধারণভাবে একটি কঠিন অনুসন্ধান সমস্যা হিসেবে পরিচিত; তাই tool-গুলো AETG-ধাঁচের greedy, Yu Lei ও সহকর্মীদের IPOG-এর মতো parameter একটি একটি করে বাড়ানোর পদ্ধতি, simulated annealing-এর মতো স্থানীয় অনুসন্ধান, বা constraint-এর জন্য SAT/SMT solver ব্যবহার করে (solver-এর ধারণা ডিসক্রিট ম্যাথ কোর্সের পর্ব ৭৭-এ)। গবেষকেরা বিভিন্ন আকারের জন্য এখন পর্যন্ত জানা সবচেয়ে ছোট covering array-র তালিকা রাখেন, আর NIST-এর ACTS নামের একটি tool t = 6 পর্যন্ত suite বানাতে পারে বলে তাদের নথিতে উল্লেখ আছে। Trade-off: ছোট suite খুঁজতে সময় লাগে, কিন্তু CI-তে প্রতিদিন চলা হাজারো test-এ কয়েকটি সারি কমানোও দীর্ঘমেয়াদে বড় সাশ্রয়।
পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এমন প্রশ্ন চেনা:
- তিন-মানের ৪টি parameter: সব মিশ্রণ, জোড়া আর ন্যূনতম pairwise test? — ৩4 = ৮১; C(4, 2) × ৯ = ৫৪; অন্তত ৯, আর L9 orthogonal array-তে ঠিক ৯.
- Parameter-এর মান-সংখ্যা ৪, ৩, ৩, ২ হলে pairwise-এর নিম্নসীমা? — সবচেয়ে বড় দুইয়ের গুণফল, ৪ × ৩ = ১২.
- দুই-মানের ৩টি parameter-এ ন্যূনতম pairwise test? — ৪টি (সব মিশ্রণ ৮টির অর্ধেক)।
- Orthogonal array আর pairwise suite-এর পার্থক্য? — প্রথমটিতে প্রতিটি জোড়া সমান সংখ্যকবার, দ্বিতীয়টিতে অন্তত একবার (covering array).
- Pairwise কোন ভুল ফসকাতে পারে? — তিন বা বেশি parameter-এর নির্দিষ্ট মিলনে ঘটা ভুল, আর model-এ না থাকা মানের ভুল।
১০ · AI-এর যুগে pairwise
AI assistant-কে “এই checkout-এর pairwise test দাও” বললে প্রায়ই একটি সুন্দর টেবিল আসে, আর সাথে আত্মবিশ্বাসী দাবি: “সব জোড়া ঢাকা হয়েছে”। হাতে গুনলে প্রায়ই দেখা যায় কয়েকটি জোড়া নেই, বা constraint ভাঙা সারি আছে; ভাষার মডেল জোড়া গোনে না, দেখতে-ঠিক টেবিল লেখে। আরও কিছু চেনা অভ্যাস: শুধু happy path-এর মান রাখা (অবৈধ মান নেই), expected কলামে কোড যা করে তাই বসানো (ভুল কোডেও সবুজ test), PICT-এর অস্তিত্বহীন option বা ভুল constraint-বাক্য বানানো, অপেক্ষার জন্য sleep বসানো, payment পুরোটা mock করে আসল যুক্তি test না করা, আর test না চালিয়েই “all tests pass” দাবি।
AI-কে সংখ্যা গুনতে নয়, model লিখতে কাজে লাগান; suite বানাক tool, আর যাচাই করুন আপনি:
AI-এর দেওয়া combinatorial suite হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১“বেশিরভাগ ভুল এক বা দুই parameter-এর মিলনে ঘটে” — এই দাবির প্রমাণ কতটা শক্ত, আর কোথায় এটি ভুল পথে নিতে পারে?
দাবিটির সবচেয়ে বেশি উদ্ধৃত ভিত্তি NIST-এর গবেষকদের কাজ। D. Richard Kuhn আর Michael Reilly ২০০২ সালের দিকে একটি browser আর একটি server-এর open-source bug database বিশ্লেষণ করেন; ২০০৪ সালে Kuhn, Dolores Wallace ও Albert Gallo IEEE Transactions on Software Engineering-এ আরও কয়েকটি ক্ষেত্র, যেমন চিকিৎসা যন্ত্রের software, যুক্ত করে ফল প্রকাশ করেন। প্রতিটি ভুলের জন্য তাঁরা প্রশ্ন করেন: কতগুলো parameter-এর নির্দিষ্ট মান একসাথে না এলে এই failure ঘটত না? তাঁদের প্রকাশিত ফলে, যতদূর জানা যায়, প্রবণতাটি একই: এক parameter-এ বড় অংশ, দুইয়ে আরও অনেকটা, তারপর দ্রুত কমে, আর তাঁদের নমুনার সব ভুল ছয় বা তার কম parameter-এর মিলনে ঘটেছিল। এই পর্যবেক্ষণকে কখনো “interaction rule” বলা হয়।
তবে সতর্কতা কয়েকটি। প্রথমত, নমুনা নির্দিষ্ট কিছু system-এর, আর প্রতিবেদিত bug-এর; যে ভুল কেউ খুঁজে পায়নি, তা হিসাবে নেই। দ্বিতীয়ত, শতাংশ ক্ষেত্রভেদে আলাদা ছিল; কোনো একটি সংখ্যা (যেমন “৯০%”) সব software-এ খাটবে, এমন কথা প্রবন্ধ বলে না। তৃতীয়ত, “parameter” কী, সেটি model-এর ওপর নির্ভর করে: একজনের মডেলে যা একটি parameter, আরেকজনের মডেলে তা দুটি।
ভুল পথে নেওয়ার জায়গা: দলগুলো কখনো pairwise-কে পূর্ণ নিরাপত্তার সনদ ভাবে। §৬-এ দেখেছেন card·iPhone·English-এর মতো তিন-মানের ভুল ১৪টি সবুজ-প্রায় test-এর ফাঁক দিয়ে বেরিয়ে যায়। আর মানগুলো খারাপভাবে বাছলে (যেমন slot-এর মান থেকে মধ্যরাতের সীমা বাদ) কোনো t-ই সাহায্য করে না। Interaction rule আসলে একটি অনুপাতের কথা, তাই এর যুক্তিসংগত ব্যবহার ঝুঁকিভিত্তিক: সাধারণ configuration-এ pairwise, টাকা বা নিরাপত্তার পথে 3-way বা 4-way, আর জানা ঝুঁকির নির্দিষ্ট মিশ্রণ হাতে seed করা।
মূল উপলব্ধি: Pairwise-এর পক্ষে প্রমাণ বাস্তব কিন্তু পরিসংখ্যানগত; এটি “কোথায় প্রথমে খুঁজব” বলে, “আর খোঁজার দরকার নেই” বলে না।
প্র ০২Euler-এর ৩৬ জন অফিসারের ধাঁধা থেকে software testing — orthogonal Latin square-এর ইতিহাস আমাদের কী শেখায়?
১৭৮২ সালে Leonhard Euler একটি ধাঁধা নিয়ে লেখেন: ছয়টি রেজিমেন্ট থেকে ছয় পদমর্যাদার একজন করে, মোট ৩৬ জন অফিসারকে ৬ × ৬ বর্গে এমনভাবে সাজানো যাবে কি, যাতে প্রতিটি সারি আর কলামে প্রতিটি রেজিমেন্ট আর প্রতিটি পদমর্যাদা একবার করে থাকে? আধুনিক ভাষায় এটি দুটি পরস্পর orthogonal ৬ মাপের Latin square খোঁজা। Euler সমাধান পাননি, আর অনুমান করেন যে ৪ দিয়ে ভাগ করলে ২ ভাগশেষ থাকে এমন কোনো মাপে (৬, ১০, ১৪, …) এমন জোড়া নেই। ১৯০০ সালে Gaston Tarry প্রায় সব সম্ভাবনা যাচাই করে দেখান, ৬-এর জন্য সত্যিই নেই। কিন্তু ১৯৫৯ সালে R. C. Bose, S. S. Shrikhande ও E. T. Parker দেখান বাকি মাপগুলোতে Euler ভুল ছিলেন: ২ আর ৬ ছাড়া সব মাপে এমন জোড়া আছে। গণিতের ইতিহাসে এটি একটি বিখ্যাত অনুমান-ভাঙার গল্প।
Software testing-এ এর সরাসরি ছায়া পড়ে। দুটি orthogonal Latin square মানে orthogonal array: সারি, কলাম আর দুই square-এর অক্ষর মিলে চারটি parameter, প্রতিটি জোড়া ঠিক একবার। ১৯৮৫ সালে Mandl ঠিক এভাবে Ada compiler-এর test সাজানোর প্রস্তাব দেন। কিন্তু ইতিহাসটি একটি সীমাও দেখায়: ছয়টি মানের চারটি parameter-এর জন্য ৩৬ সারির নিখুঁত orthogonal array নেই, কারণ Tarry-র ফল। Parameter-এর আকার মিশ্র হলে সমস্যা আরও বাড়ে।
Testing তাই নিখুঁত ভারসাম্যের দাবি ছেড়ে covering array-র দিকে গেছে: প্রতিটি জোড়া অন্তত একবার, যেকোনো আকারে, প্রায়ই আরও কম সারিতে। এটি প্রকৌশলের চেনা চাল: পরিসংখ্যানবিদের প্রয়োজন (প্রতিটি প্রভাব আলাদা করে মাপা) আর tester-এর প্রয়োজন (প্রতিটি মিলন অন্তত একবার দেখা) আলাদা, তাই সমাধানও আলাদা।
মূল উপলব্ধি: একটি কৌশল অন্য ক্ষেত্র থেকে ধার করলে তার শর্তগুলোও প্রশ্ন করুন; নিজের লক্ষ্যের জন্য অপ্রয়োজনীয় শর্ত ছাড়লে প্রায়ই সহজ আর ভালো সমাধান মেলে।
প্র ০৩আমাদের greedy ১৩টি, PICT ১৫টি, নিম্নসীমা ১২টি — সবচেয়ে ছোট suite খুঁজে বের করা এত কঠিন কেন, আর আদৌ দরকার কি?
সবচেয়ে ছোট covering array খোঁজা একটি বিশাল অনুসন্ধান: প্রতিটি সারির জন্য ২১৬টি সম্ভাবনা, আর ১২টি সারির সম্ভাব্য সাজানো জ্যোতির্বিজ্ঞানের সংখ্যার মতো। সাধারণভাবে এই ধরনের সমস্যা গণনার দিক থেকে কঠিন বলে পরিচিত, আর ছোট উদাহরণেও নিশ্চিত ন্যূনতম প্রমাণ করা সময়সাপেক্ষ। তাই বাস্তব tool heuristic নেয়। AETG (১৯৯৭) প্রতিটি নতুন সারির জন্য কয়েকটি প্রার্থী বানিয়ে সেরাটি নিত; IPOG-ধাঁচের পদ্ধতি প্রথমে দুই parameter-এর সব জোড়া বসায়, তারপর একটি একটি করে parameter যোগ করে প্রয়োজনে সারি বাড়ায়; কিছু গবেষণা-tool simulated annealing বা SAT solver দিয়ে আরও ছোট suite খোঁজে। আমাদের greedy সব ২১৬টি সারি দেখে, যা ছোট model-এ চলে কিন্তু বড় model-এ (ধরুন ১৫টি parameter) অসম্ভব ধীর।
আদৌ দরকার কি? হিসাবটা খরচের। ১৩ বনাম ১৫ মানে দুটি test; একবার manual চালালে নগণ্য। কিন্তু প্রতিটি সারি যদি একটি পুরো browser-device test হয়, প্রতিদিন CI-তে চলে, আর বছরে কয়েকশো বার, তাহলে দুটি সারির দাম ঘণ্টায় দাঁড়ায়। অন্যদিকে ছোট suite খুঁজতে generator-এর সময়, আর model বদলালে পুরো suite বদলে যাওয়ার অস্থিরতা।
বাস্তবে অনেক দল তাই সংখ্যার চেয়ে অন্য গুণে বেশি গুরুত্ব দেয়: নির্ধারিত আউটপুট (একই model-এ একই suite, যাতে পুরোনো ফলাফলের সাথে তুলনা চলে), seeding (জরুরি সারি সবসময় থাকবে), constraint-এর সঠিক ব্যবস্থা, আর model ফাইল version control-এ রাখা। PICT ডিফল্টে নির্ধারিত আউটপুট দেয়; আমাদের greedy-ও, কারণ সমান হলে সবসময় প্রথম সারি নেয়।
মূল উপলব্ধি: ন্যূনতম suite একটি সুন্দর গাণিতিক লক্ষ্য, কিন্তু প্রকৌশলের লক্ষ্য হলো যাচাইযোগ্য, স্থির আর রক্ষণাবেক্ষণযোগ্য suite; নিম্নসীমার কাছাকাছি থাকলেই সাধারণত যথেষ্ট।
প্র ০৪Pairwise suite-এ একটি সারি লাল হলো। কোন মিলনটি দায়ী, তা কীভাবে নিশ্চিত হবেন?
Combinatorial testing-এর একটি কম আলোচিত দিক এটি: suite ভুলের অস্তিত্ব জানায়, কিন্তু ঠিকানা দেয় না। একটি লাল সারিতে পাঁচটি মান, অর্থাৎ ১০টি জোড়া আর ১০টি triple; যেকোনোটি দায়ী হতে পারে। §৬-এ C10 (Ctg, wallet, morning, tablet, bn) লাল হলো। প্রথম ধাপ সবুজ সারিগুলো থেকে সন্দেহ ছাঁটাই: কোনো সবুজ সারিতে যে জোড়া আছে, সেটি একা দায়ী হতে পারে না (ধরে নিচ্ছি failure নির্ধারিত, অর্থাৎ একই input-এ সবসময় ঘটে)। C10-এর ১০টি জোড়ার মধ্যে wallet·tablet কোনো সবুজ সারিতে নেই; বাকিগুলোর অনেকগুলো আছে। সন্দেহের তালিকা দ্রুত ছোট হয়ে আসে।
দ্বিতীয় ধাপ নতুন test দিয়ে নিশ্চিত হওয়া: লাল সারি থেকে একবারে একটি মান বদলে নতুন সারি বানান। Tablet বদলে android করলে সবুজ, wallet বদলে cash করলে সবুজ, কিন্তু জেলা বা slot বদলালে লাল থাকে: তাহলে wallet·tablet. গবেষণায় এই কাজের নাম fault localization বা failure-inducing combination খোঁজা, আর এর জন্য স্বয়ংক্রিয় পদ্ধতিও প্রস্তাবিত হয়েছে। Andreas Zeller-এর delta debugging-এর ধারণাও কাছাকাছি: failure ধরে রেখে input যতটা পারা যায় ছোট করা।
Bug report-এর জন্য এই ছাঁটাই খুব মূল্যবান। “C10 fail করেছে” developer-কে প্রায় কিছুই বলে না; “wallet আর tablet একসাথে হলেই, জেলা-slot-ভাষা যা-ই হোক” বললে তিনি সরাসরি tablet-এর wallet redirect দেখবেন। পর্ব ১৮-এ bug report-এর এই অংশটিকে বলব সর্বনিম্ন পুনরুৎপাদনের ধাপ।
একটি ফাঁদ: failure নির্ধারিত না হলে (যেমন timing-নির্ভর, পর্ব ৪০-এর flaky test) এই যুক্তি ভেঙে পড়ে, কারণ একই সারি কখনো সবুজ, কখনো লাল। তখন একাধিকবার চালিয়ে আগে নির্ধারণ করতে হয় ভুলটি আসলে মিলনের, না সময়ের।
মূল উপলব্ধি: Pairwise suite খোঁজার জাল ফেলে; লাল সারি পেলে সবুজ সারির সাথে তুলনা আর এক-মান-বদলের test দিয়ে জালটিকে নির্দিষ্ট মিলনে নামিয়ে আনাই tester-এর আসল দক্ষতা।
প্র ০৫Browser, OS, device আর ভাষার matrix প্রতি বছর বড় হয়। Pairwise কি একা এই সমস্যার সমাধান?
Configuration-এর জগৎ সত্যিই দ্রুত ফোলে। একটি web app-এর জন্য কয়েকটি browser, প্রতিটির কয়েকটি version, কয়েকটি OS, বহু screen-আকার, দুটি ভাষা, আলো আর অন্ধকার theme; mobile app-এ আরও Android version, নির্মাতার নিজস্ব পরিবর্তন আর নেটওয়ার্কের ধরন। সব মিশ্রণ সহজেই হাজার ছাড়ায়। Pairwise এখানে স্বাভাবিক হাতিয়ার, কারণ বেশিরভাগ compatibility ভুল সত্যিই একটি বা দুটি জিনিসের মিলনে দেখা দেয়, যেমন একটি browser-এর একটি নির্দিষ্ট version, বা একটি OS আর একটি font.
কিন্তু একা নয়। প্রথমত, মান বাছাই নিজেই একটি ঝুঁকির সিদ্ধান্ত: কোন browser version রাখবেন, তা ঠিক হয় ব্যবহারকারীর আসল ব্যবহার-তথ্য দেখে (বাজারঘরের analytics কোন device বেশি দেখায়), আর ঝুঁকিভিত্তিক অগ্রাধিকারে (পর্ব ৭৩)। দ্বিতীয়ত, সবচেয়ে বেশি ব্যবহৃত মিশ্রণগুলো (ধরুন Android phone, বাংলা, mobile-wallet) এত গুরুত্বপূর্ণ যে সেগুলো seed করে প্রতিবার চালানো হয়, pairwise-এর সারিতে আসুক বা না আসুক। তৃতীয়ত, সব কিছু সমান গভীরে নয়: পুরো regression চলে একটি-দুটি প্রধান configuration-এ, আর pairwise matrix চলে ছোট smoke suite দিয়ে।
খরচের দিকটিও আছে। Cloud device farm বা অনেক browser-এ test চালাতে সময় আর যন্ত্র লাগে; CI-তে প্রতিটি সারি একটি parallel job. তাই pairwise-এর সংখ্যা কমানো সরাসরি feedback-এর সময় কমায় (পর্ব ৬৪, ৬৮)। আর প্রতি release-এর পর model হালনাগাদ করতে হয়: পুরোনো browser version বাদ, নতুন যোগ; model ফাইলকে কোডের মতো review করা ভালো অভ্যাস। বাজারঘরের ক্ষেত্রে model ফাইলটি test কোডের পাশে একই repository-তে রাখলে কোন release-এ কোন মান যোগ বা বাদ হলো, তার ইতিহাসও থেকে যায়।
মূল উপলব্ধি: Pairwise configuration-এর বিস্ফোরণকে সামলানোর মতো আকারে নামায়, কিন্তু কোন মান, কোন মিশ্রণ সবসময়, আর কতটা গভীরে, সেই সিদ্ধান্ত আসে ব্যবহার-তথ্য আর ঝুঁকি থেকে।
অনুশীলন
কাগজে-কলমে করুন; শেষে উত্তর মিলিয়ে নিন।
-
Test design: বাজারঘর অর্ডারের খবর পাঠায়। Parameter: channel (SMS, email, app push), ভাষা (বাংলা, ইংরেজি), গ্রাহক (নতুন, পুরোনো)। সব মিশ্রণ কয়টি, মোট মান-জোড়া কয়টি, নিম্নসীমা কত? সব জোড়া ঢাকে এমন একটি ন্যূনতম suite লিখুন।
সব মিশ্রণ ৩ × ২ × ২ = ১২. জোড়া: channel × ভাষা ৬, channel × গ্রাহক ৬, ভাষা × গ্রাহক ৪; মোট ১৬. নিম্নসীমা ৩ × ২ = ৬. একটি ৬-সারির suite: SMS·বাংলা·নতুন, SMS·ইংরেজি·পুরোনো, email·বাংলা·পুরোনো, email·ইংরেজি·নতুন, push·বাংলা·নতুন, push·ইংরেজি·পুরোনো. প্রতিটি channel দুই ভাষা আর দুই ধরনের গ্রাহক পায়, আর ভাষা × গ্রাহকের চারটি জোড়া (বাংলা·নতুন, ইংরেজি·পুরোনো, বাংলা·পুরোনো, ইংরেজি·নতুন) সবই আছে: ১৬টির ১৬টি (scratch checker-এ মেলানো)। এটি §৩-এর stepper-এর একই গঠন, শুধু নাম বদলেছে।
-
Failure পড়ুন: Constraint মানা ১৪টি pairwise test চালানোর পর শুধু C10 (Ctg · wallet · morning · tablet · bn) লাল, বার্তা
RuntimeError: wallet mock: redirect lost. সবুজ সারির মধ্যে আছে C02 (Dhaka · wallet · afternoon · iphone · en), C06 (Dhaka · wallet · evening · desktop · bn), C08 (Rajshahi · wallet · morning · android · en), C04 (Rajshahi · card · afternoon · tablet · bn), C05 (Dhaka · cash · evening · tablet · en). কোন মিলন সবচেয়ে সন্দেহজনক, কেন, আর নিশ্চিত হতে কোন দুটি নতুন test চালাবেন? বার্তাটি FAIL না হয়ে ERROR কেন?Wallet একা দায়ী নয়: C02, C06, C08-এ wallet আছে, সবুজ। Tablet একা নয়: C04, C05 সবুজ। Wallet·morning (C08-এ আছে), Ctg·wallet বা অন্য জোড়াগুলোর অনেকগুলোও সবুজ সারিতে আছে; কিন্তু wallet·tablet কোনো সবুজ সারিতে নেই। তাই সবচেয়ে সন্দেহজনক wallet·tablet. নিশ্চিত হতে C10 থেকে একবারে একটি মান বদলান: (১) tablet বদলে android, বাকি একই: সবুজ হলে device জড়িত; (২) wallet বদলে cash: সবুজ হলে payment জড়িত। আর জেলা বা slot বদলেও লাল থাকলে সেগুলো নির্দোষ।
ERROR কারণ
place_orderনিজেই exception ছুড়েছে, assertion তুলনা পর্যন্ত পৌঁছায়নি; FAIL হয় যখন assertion-এ মান মেলে না। -
Test-এর ভুল খুঁজুন: একজন tester লিখেছেন: “browser (Chrome, Firefox), OS (Windows, Android), ভাষা (bn, en)-এর জন্য ৪টি সারিতে ১০০% pair coverage.” তাঁর সারি: Chrome·Windows·bn, Chrome·Android·en, Firefox·Windows·en, Firefox·Android·en. দাবিটি কি ঠিক? না হলে কোন জোড়া নেই, coverage কত, আর একটি মান বদলে কীভাবে ঠিক করবেন?
মোট জোড়া ৩ × ৪ = ১২. browser × OS-এর চারটিই আছে। কিন্তু Firefox·bn নেই (Firefox-এর দুই সারিতেই en), আর Android·bn নেই। Coverage ১০ ÷ ১২ = ৮৩.৩%, ১০০% নয়। শেষ সারি Firefox·Android·en-কে Firefox·Android·bn করলে দুটি জোড়া আসে, আর হারানো জোড়া Firefox·en আর Android·en অন্য সারিতে (Firefox·Windows·en, Chrome·Android·en) আগেই আছে: ১২টির ১২টি (scratch checker-এ মেলানো)। শিক্ষা: “১০০%” দাবি হাতে বা checker দিয়ে গুনে দেখুন; দুই-মানের তিন parameter-এ ৪টি সারি যথেষ্ট, কিন্তু যেকোনো ৪টি নয়।
-
গুনে দেখুন: একটি settings পাতায় পাঁচটি parameter: চারটির প্রতিটিতে ৩টি মান, একটিতে ২টি। সব মিশ্রণ, মোট মান-জোড়া আর pairwise-এর নিম্নসীমা বের করুন। একটি suite এর ৬২টি জোড়া ঢাকলে pair coverage কত?
সব মিশ্রণ ৩4 × ২ = ১৬২. জোড়া: তিন-মানের parameter-জোড়া C(4, 2) = ৬টি, প্রতিটিতে ৯, মোট ৫৪; তিন-মানের প্রতিটির সাথে দুই-মানেরটি ৪ × ৬ = ২৪; সব মিলিয়ে ৭৮. নিম্নসীমা ৩ × ৩ = ৯. ৬২টি জোড়া ঢাকলে coverage ৬২ ÷ ৭৮ ≈ ৭৯.৫%. (সংখ্যাগুলো scratch script-এ মেলানো।)
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমএকটি pairwise test suite বানানোর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Requirement আর পরিবেশ থেকে parameter চিহ্নিত করা
- EP আর BVA দিয়ে প্রতিটি parameter-এর মান বাছা
- অসম্ভব মিশ্রণের constraint আর অবৈধ মান লেখা
- Tool দিয়ে suite বানানো
- Pair coverage আর constraint ভাঙা সারি যাচাই করা
- Requirement থেকে expected লিখে test চালানো
একটি checkout-এ জেলা ৩টি, payment ৩টি, slot ৩টি, device ৪টি আর ভাষা ২টি মানে নেওয়া হলো। সব মিশ্রণ (exhaustive) কয়টি?
- ১৫
- ৮৯
- ২১৬
- ২৪৩
চারটি parameter-এর মান-সংখ্যা ৪, ৩, ৩ আর ২। যেকোনো pairwise suite-এ অন্তত কয়টি test লাগবে?
- ৪
- ১২
- ৭২
- ৫৩
একটি test suite-কে “pairwise” বলার শর্ত কোনটি?
- যেকোনো দুই parameter-এর প্রতিটি সম্ভবপর মান-জোড়া অন্তত একটি test-এ আছে
- প্রতিটি parameter-এর প্রতিটি মান অন্তত একবার আছে
- প্রতিটি মান-জোড়া ঠিক একবার আছে, বেশি নয়
- যেকোনো তিন parameter-এর প্রতিটি মিশ্রণ আছে
একটি model-এ সম্ভবপর মান-জোড়া ৯০টি; একটি suite তাদের ৭২টি ঢাকে। Pair coverage কত?
- ২০%
- ৭২%
- ১০০%
- ৮০%
Model-এর constraint: IF [District] <> "Dhaka" THEN [Slot] <> "Evening"; নিচের কোন সারি এই নিয়ম ভাঙে?
- Dhaka · Cash · Evening · Android · Bangla
- Rajshahi · Wallet · Evening · Tablet · English
- Chattogram · Card · Morning · iPhone · English
- Rajshahi · Cash · Afternoon · Desktop · Bangla
তিনটি parameter, প্রতিটির ২টি মান (মোট মিশ্রণ ৮টি)। সব মান-জোড়া ঢাকতে ন্যূনতম কয়টি test লাগে?
- ২
- ৩
- ৪
- ৮
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- সব মিশ্রণ = মান-সংখ্যার গুণফল; মান-জোড়া = প্রতিটি parameter-জোড়ার গুণফলের যোগফল; নিম্নসীমা = সবচেয়ে বড় দুইয়ের গুণফল।
- Pairwise: প্রতিটি সম্ভবপর মান-জোড়া অন্তত একবার; checkout-এ ২১৬ থেকে ১৩টি test, constraint-সহ ১৪টি।
- Orthogonal array জোড়া সমান সংখ্যকবার আনে; covering array অন্তত একবার, যেকোনো আকারে। Tool দ্বিতীয়টি বানায়।
- অসম্ভব মিশ্রণ constraint দিয়ে বাদ দিন, অবৈধ মান এক সারিতে একটিই; tool-এর suite নিজের checker দিয়ে যাচাই করুন।
- তিন-মানের defect pairwise ফসকাতে পারে; ঝুঁকির জায়গায় 3-way. Expected সবসময় requirement থেকে।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ১২ · Use case আর scenario testing — ব্যবহারকারীর যাত্রা ধরে testপরবর্তী পর্বCheckout-কে use case হিসেবে লিখে মূল আর বিকল্প পথ থেকে scenario test.
- সফটওয়্যার টেস্টিং ও QA · কোর্স হোম৮২টি পর্ব১৪টি মডিউলের পুরো রোডম্যাপ।
- পর্ব ০৯ · Decision table আর cause-effectপাশাপাশি পড়ুনযখন নির্দিষ্ট শর্তের প্রতিটি মিশ্রণ গুরুত্বপূর্ণ, তখন pairwise নয়, decision table.
- সফটওয়্যার ইঞ্জিনিয়ারিং ও Git · পর্ব ৪৭পাশের ট্র্যাকTest design-এর কৌশলগুলো এক পর্বে, সংক্ষেপে; ৮১ থেকে ৯-এর উদাহরণ।
- ডিসক্রিট ম্যাথ · পর্ব ৩৩গভীরে যানC(n, k) আর বিন্যাস-সমাবেশ: জোড়া আর triple গোনার গণিত।