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

Decision table আর cause-effect — নিয়মের সব মিশ্রণ

Decision Table Testing and Cause-Effect Graphing — Every Combination of the Rules

Taught in Bangla, this lesson builds a full decision table from the Bazarghar delivery charge rules, three conditions and eight rules, then collapses it with don't-care entries and verifies the collapse by rule count and expansion. In-page Python turns columns into unittest cases and shows a collapsed table letting a seeded defect through that the full table catches. It finds gaps and conflicts in a draft requirement, handles infeasible columns and extended entries, and reads a cause-effect graph.

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

  • Requirement থেকে শর্ত আর কাজ বের করে নিয়মমাফিক পূর্ণ decision table বানানো
  • Don't-care দিয়ে টেবিল ছোট করা, আর rule-count ও খুলে মেলানো দিয়ে ছোট করা ঠিক কি না যাচাই
  • প্রতিটি কলাম থেকে test case, coverage-এর শতাংশ আর অসম্ভব (infeasible) কলামের হিসাব
  • খসড়া requirement-এ ফাঁক, বিরোধ আর ক্ষতিহীন overlap খুঁজে product owner-কে সঠিক প্রশ্ন করা
  • Cause-effect graph পড়া, আর AI-এর বানানো decision table যাচাই করা

১ · এক ঘর নয়, কয়েকটি শর্ত একসাথে

পর্ব ০৭ (Equivalence partitioning — অসংখ্য input থেকে অল্প কয়েকটি test) আর পর্ব ০৮ (Boundary value analysis — দুই-মান আর তিন-মান পদ্ধতি) একটি একটি input-এর ভেতরটা দেখে: কোন মানগুলো একই দলে, আর দলের সীমা কোথায়। কিন্তু অনেক নিয়মে প্রশ্নটা অন্য রকম। ফল নির্ভর করে কয়েকটি শর্ত একসাথে কেমন, তার ওপর। এমন জায়গায় একটি একটি ঘর আলাদা করে test করলে মিশ্রণের bug ফসকে যায়।

মোবাইল রিচার্জের একটি অফারের পোস্টার ভাবুন: “৫০ টাকা বা বেশি রিচার্জে বোনাস মিনিট। নতুন সিমে বোনাস দ্বিগুণ। রাত ১২টার পর রিচার্জে বাড়তি ডেটা।” একজন গ্রাহক জানতে চাইলেন, “আমার নতুন সিম, ৪০ টাকা রিচার্জ করেছি রাত একটায়। আমি কী পাব?” পোস্টারে উত্তর নেই। নতুন সিমের দ্বিগুণ কি ৫০ টাকার কমেও খাটে? তিনটি বাক্য আলাদাভাবে পরিষ্কার, কিন্তু তাদের মিশ্রণ নিয়ে কেউ ভাবেনি। Decision table ঠিক এই কাজটি করায়: প্রতিটি মিশ্রণের জন্য একটি কলাম, আর প্রতিটি কলামে লিখিত উত্তর।

বাজারঘরের delivery charge-এর নিয়ম এই কোর্সে স্থির। এই পর্বে তার সাথে একটি নতুন শর্ত যোগ হচ্ছে: বাজারঘর Plus নামের সদস্যপদ। পুরো পর্বে নিয়মটি এমন:

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

Delivery charge: ঢাকার ভেতরে ৬০ টাকা, বাইরে ১২০ টাকা। অর্ডার ২০০০ টাকা বা বেশি হলে ঢাকার ভেতরে delivery ফ্রি। নতুন: Plus সদস্যের ঢাকার বাইরের delivery charge ৬০ টাকা। এখানে “অর্ডার” মানে পণ্যের মোট দাম, coupon-এর ছাড়ের আগে।

Coupon: অর্ডার ১০০০ টাকার বেশি হলে ১০% ছাড়, সর্বোচ্চ ৩০০ টাকা; ছাড় পূর্ণ টাকায়, ভগ্নাংশ বাদ; ছাড় শুধু পণ্যের দামে, delivery charge-এ নয়।

এখানে তিনটি প্রশ্ন একসাথে কাজ করে: ঠিকানা ঢাকার ভেতরে কি না, অর্ডার ২০০০ বা বেশি কি না, ক্রেতা Plus সদস্য কি না। Plus সদস্য ঢাকার ভেতরে ২৫০০ টাকার অর্ডার দিলে কত? এক ঝলকে মনে হতে পারে, সদস্যের ৬০ টাকার নিয়মটিও এখানে খাটে। ঠিক এমন জায়গায় developer-এর কোডে if-এর ক্রম উল্টে যায়, আর bug লুকিয়ে থাকে।

সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৪৭-এ একটি বাস-ভাড়ার উদাহরণে decision table বানানো আর ছোট করা এক অংশে দেখেছেন (না পড়লেও চলবে)। এখানে পুরো পদ্ধতি: নিয়মমাফিক ধাপ, ছোট করার যাচাই, coverage, requirement-এর ফাঁক খোঁজা, অসম্ভব মিশ্রণ, cause-effect graph, আর প্রতিটি ধাপের পরে চালানো test.

Decision table testing-এর চেয়ে পুরোনো। ১৯৫০ আর ১৯৬০-এর দশকে ব্যবসায়িক data processing-এ program-এর যুক্তি লেখার একটি উপায় হিসেবে এটি ব্যবহার হতো; আমাদের জানামতে ১৯৬২ সালের দিকে CODASYL-এর একটি দল DETAB-X নামে decision table-ভিত্তিক একটি ভাষার প্রস্তাবও দিয়েছিল। Testing-এ এর জনপ্রিয়তা বাড়ে Glenford Myers-এর “The Art of Software Testing” (১৯৭৯) বইয়ের পরে, যেখানে cause-effect graph থেকে decision table আর test বের করার পদ্ধতি বিস্তারিত বলা আছে। আজ ISTQB-এর syllabus-এ এটি black-box কৌশলগুলোর একটি।

২ · টেবিলের চার অংশ আর rule গোনা

Requirement-এর প্রতিটি “যদি” একটি শর্ত (condition), প্রতিটি “তাহলে” একটি কাজ (action). টেবিলের প্রতিটি কলাম একটি rule: শর্তগুলোর একটি নির্দিষ্ট মিশ্রণ আর সেই মিশ্রণে প্রত্যাশিত কাজ। কাজের সারিটিই আপনার test oracle, অর্থাৎ test পাস না ফেল তা বিচারের মাপকাঠি। নিচে delivery charge-এর ছোট করা টেবিল, চার অংশ চার রঙে:

Decision table-এর চার অংশ

Delivery charge, ছোট করা রূপ: কলাম = rule, “−” = don't-care

Decision table anatomy: condition stub, condition entries, action stub, action entries নিয়ম (rule) → C1 ঢাকার ভেতরে C2 অর্ডার ≥ ২০০০ C3 Plus সদস্য A1 charge (টাকা) R1R2R3R4 YYNN YN−− −−YN 06060120 শর্তের তালিকা · condition stub শর্তের মান · condition entries কাজের তালিকা · action stub কাজের মান · action entries
ছবি ৯.১ — বাঁ দিকে কী প্রশ্ন আর কী কাজ, ডান দিকে প্রতিটি rule-এর উত্তর। চারটি কলাম আসলে পূর্ণ টেবিলের আটটি কলামকে ঢাকে, কারণ প্রতিটি “−” দুটি কলামের জায়গা নেয়।

শর্তের ঘরে কী বসে, তা দিয়ে টেবিলের তিন ধরন:

  • Limited entry: প্রতিটি শর্ত Y/N (সত্য/মিথ্যা)। সবচেয়ে প্রচলিত, আর এই পর্বের বেশিরভাগ টেবিল এমন।
  • Extended entry: শর্তের দুইয়ের বেশি মান, যেমন “অর্ডারের পরিমাণ: ১০০০ বা কম / ১০০১–১৯৯৯ / ২০০০–২৯৯৯ / ৩০০০ বা বেশি”। এই দলগুলো আসে equivalence partitioning থেকে।
  • Mixed: কিছু শর্ত Y/N, কিছু বহু-মানের। কাজের ঘরেও একই কথা: “X চিহ্ন দিলে কাজটি হবে”, অথবা সরাসরি একটি মান (৬০ টাকা)।

কলাম গোনা গণনার গুণের নিয়ম (product rule): প্রতিটি শর্তের মানের সংখ্যা গুণ করুন। ডিসক্রিট ম্যাথ কোর্সের পর্ব ৩১-এ নিয়মটির গণিত আছে।

গোনার সূত্র

n-টি Y/N শর্ত: পূর্ণ টেবিলে 2nটি কলাম। শর্তগুলোর মান-সংখ্যা v1, v2, …, vn হলে কলাম v1 × v2 × … × vn. উদাহরণ: ৩টি Y/N শর্ত → ৮; ৪টি Y/N আর একটি তিন-মানের শর্ত → 24 × 3 = ৪৮; ১০টি Y/N শর্ত → ১০২৪।

শেষ সংখ্যাটিই বলে দেয় কেন বড় নিয়মকে ছোট ছোট টেবিলে ভাঙতে হয়। ১০২৪টি কলামের টেবিল কেউ পড়ে না, আর তার প্রতিটি কলামের উত্তর কেউ নিশ্চিতভাবে জানেও না। সাধারণ চর্চা: একটি টেবিলে চার-পাঁচটির বেশি শর্ত না রাখা, আর এক টেবিলের ফলকে অন্য টেবিলের শর্ত বানানো (যেমন আগে “ছাড় কত” টেবিল, তার ফল নিয়ে “মোট বিল” টেবিল)।

৩ · পূর্ণ টেবিল বানানো — নিয়মমাফিক ধাপ

পদ্ধতিটি যান্ত্রিক, আর সেটাই তার শক্তি। Requirement যত জটিলই হোক, নিচের ধাপগুলো মেনে চললে কোনো মিশ্রণ বাদ পড়ে না:

  1. শর্ত আর কাজ খুঁজুন। প্রতিটি “যদি”, “হলে”, “শুধু”, “ছাড়া” শব্দ চিহ্নিত করুন। শর্তগুলো যেন পরস্পর স্বাধীন আর স্পষ্ট হয়। সংখ্যার শর্ত হলে (অর্ডার ২০০০ বা বেশি) সীমাটি ঠিক কোথায়, লিখে রাখুন।
  2. কলাম গুনুন। গোনার সূত্রে মোট rule. সংখ্যা খুব বড় হলে টেবিল ভাঙুন।
  3. শর্তের মান বসান। প্রথম সারিতে অর্ধেক Y, অর্ধেক N; দ্বিতীয় সারিতে তার অর্ধেক মাপে পালা করে; শেষ সারিতে একটি করে পালা। এতে কোনো মিশ্রণ বাদ বা দুবার পড়ে না।
  4. প্রতিটি কলামে কাজ লিখুন, শুধু requirement থেকে। যে কলামের উত্তর requirement-এ নেই, সেখানে আন্দাজ নয়, প্রশ্ন লিখুন।
  5. অসম্ভব কলাম চিহ্নিত করুন (একসাথে সত্য হতে পারে না এমন মিশ্রণ)। এগুলোর test হয় না।
  6. চাইলে ছোট করুন, তারপর ছোট করাটা ঠিক কি না যাচাই করুন (§৪)।
  7. প্রতিটি কলাম থেকে একটি test case: ইনপুট, প্রত্যাশিত ফল, আর কোন rule ঢাকছে (§৫)।

নিচের stepper-এ delivery charge-এর পূর্ণ টেবিল ধাপে ধাপে ভরছে। ছোট পর্দার সুবিধার জন্য এখানে প্রতিটি rule একটি সারি (R1…R8), আর ধাপ ৩–৫-এ বাঁ থেকে ডানে C1, C2, C3-এর মান বসছে। খাতায় বা নথিতে সাধারণত rule থাকে কলামে, যেমন একটু পরের টেবিলে।

শর্ত: C1 ঢাকার ভেতরে · C2 অর্ডার ≥ 2000 · C3 Plus
ধাপ
টেবিল
  1. শর্ত আর কাজ। নিয়মের বাক্য থেকে তিনটি “যদি” পাওয়া গেল: ঠিকানা ঢাকার ভেতরে কি না, অর্ডার ২০০০ বা বেশি কি না, ক্রেতা Plus সদস্য কি না। কাজ একটি: কত টাকা delivery charge. সীমাটিও লিখে রাখা হলো: ঠিক ২০০০ টাকা “বেশি”-র দলে।
  2. কলাম গোনা। প্রতিটি শর্তের দুটি মান, তাই 2 × 2 × 2 = ৮টি rule, R1 থেকে R8. এর বেশি বা কম কলাম হলে কোথাও ভুল হয়েছে।
  3. C1 বসানো। প্রথম শর্তে অর্ধেক Y (R1–R4), অর্ধেক N (R5–R8). প্রথম চারটি rule ঢাকার ঠিকানার, পরের চারটি বাইরের।
  4. C2 বসানো। দ্বিতীয় শর্তে দুটি করে পালা: Y Y N N, আবার Y Y N N. ঢাকার ভেতরে আর বাইরে, দুই জায়গাতেই বড় আর ছোট অর্ডার দুটোই এলো।
  5. C3 বসানো। শেষ শর্তে একটি করে পালা: Y N Y N … এখন আটটি সারির প্রতিটি আলাদা, আর তিনটি Y/N-এর সম্ভাব্য আটটি মিশ্রণের প্রতিটি ঠিক একবার এসেছে।
  6. কাজ বসানো। প্রতিটি সারিতে নিয়ম থেকে উত্তর। ঢাকার ভেতরে বড় অর্ডারে 0, সদস্য হোক বা না হোক (R1, R2). ঢাকার বাইরে সদস্য হলে 60, অর্ডার যত বড়ই হোক (R5, R7). এই সারিটি কোড দেখে নয়, শুধু নিয়ম পড়ে লেখা।

একই টেবিল প্রচলিত রূপে, rule কলামে। Test-এর নথিতে বা review-এর সময় এটিই দেখাবেন:

শর্ত / কাজR1R2R3R4R5R6R7R8
C1 ঢাকার ভেতরেYYYYNNNN
C2 অর্ডার ≥ 2000YYNNYYNN
C3 Plus সদস্যYNYNYNYN
A1 charge (টাকা)0060606012060120

শর্ত বাছাইয়ের সবচেয়ে সাধারণ ভুল: পরস্পর-নির্ভর শর্ত। “অর্ডার ১০০০-এর বেশি” আর “অর্ডার ২০০০ বা বেশি” দুটি আলাদা Y/N শর্ত বানালে “প্রথমটি N, দ্বিতীয়টি Y” কলামটি অসম্ভব হয়ে যায়। দ্বিতীয় সাধারণ ভুল: লুকানো শর্ত। ঠিকানা “Dhaka” না লিখে “ঢাকা” লিখলে কী হবে? এটি টেবিলের শর্ত নয়, input-এর ভেতরের দল; সেটি ধরে partition-এর কৌশল। কৌশলগুলো একসাথে কাজ করে।

৪ · Don't-care দিয়ে ছোট করা, আর ছোট করাটা যাচাই

পূর্ণ টেবিলে R1 আর R2-এর উত্তর একই (0), আর তারা আলাদা শুধু C3-এ। অর্থাৎ ঢাকার ভেতরে বড় অর্ডারে সদস্যপদের কোনো প্রভাব নেই। দুটি কলাম মিশিয়ে একটি কলাম বানানো যায়, যেখানে C3-এর ঘরে বসে “−”। এমন টেবিলকে বলে collapsed decision table (ছোট করা টেবিল)। মেশানোর নিয়ম তিনটি:

  • দুটি কলামের কাজ হুবহু এক।
  • তারা ঠিক একটি শর্তে আলাদা, আর সেখানে দুজনের কারও “−” নেই।
  • বাকি সব ঘর, “−” সমেত, একই।
rule → কাজ (◀ = এই ধাপে বদলাচ্ছে)
টেবিল
যাচাই
  1. প্রার্থী খোঁজা। YYY আর YYN: কাজ দুটোই 0, আর পার্থক্য শুধু শেষ ঘরে (C3). মেশানোর তিনটি শর্তই পূরণ হয়েছে।
  2. মেশানো আর খুলে দেখা। দুটি সারি মিলে হলো YY- → 0. যাচাই সহজ: “−”-এর জায়গায় Y আর N দুটোই বসিয়ে খুলুন, পাবেন YYY আর YYN; পূর্ণ টেবিলে দুটোরই উত্তর 0. মিল আছে, তাই মেশানো বৈধ।
  3. আরেক জোড়া। YNY আর YNN, দুটোরই 60, আলাদা শুধু C3. মিশে হলো YN- → 60. ঢাকার ভেতরে ছোট অর্ডারেও সদস্যপদের প্রভাব নেই।
  4. ঢাকার বাইরের চারটি। NYY আর NNY (দুটোই 60) আলাদা শুধু C2-এ, মিশে N-Y. NYN আর NNN (দুটোই 120) মিশে N-N. ঢাকার বাইরে অর্ডারের পরিমাণের প্রভাব নেই, সদস্যপদের আছে।
  5. যা মেশানো যায় না। YN- আর N-Y-এর কাজ এক (60), তবু মেশানো যাবে না: তারা একটি নয়, তিনটি ঘরেই আলাদা। আরেকটি ফাঁদ: ধাপ ৩-এর আগে YNY-কে NNY-এর সাথে মেশানোও বৈধ ছিল (-NY). তখন YNN আর NYY একা পড়ে যেত, আর টেবিলে থাকত ৫টি rule. কোন জোড়া আগে মেশাবেন, তাতে ফল বদলায়।
  6. Rule-count যাচাই। প্রতিটি “−” দুটি কলামের জায়গা নেয়, তাই একটি “−”-ওয়ালা rule গোনে ২। মোট 2 + 2 + 2 + 2 = ৮, পূর্ণ টেবিলের সমান। কম হলে কোনো মিশ্রণ বাদ পড়েছে, বেশি হলে কোনো মিশ্রণ দুটি rule-এ ঢুকেছে।

শেষ ধাপের হিসাবটির নাম rule-count check: n-টি Y/N শর্তের টেবিলে প্রতিটি rule গোনে 2(“−”-এর সংখ্যা), আর সবগুলোর যোগফল ঠিক 2n হতে হবে। হাতে করা সহজ, কিন্তু এটি শুধু সংখ্যা মেলায়। উত্তরও মেলাতে হলে প্রতিটি ছোট rule খুলে পূর্ণ টেবিলের সাথে মেলাতে হয়। নিচের Python ঠিক এই দুটি কাজ করে: নিয়ম থেকে পূর্ণ টেবিল বানায়, বারবার জোড়া মিশিয়ে ছোট করে, তারপর ছোট টেবিল আর একজন সহকর্মীর হাতে ছোট করা একটি টেবিল দুটোই যাচাই করে। “চালান” চাপুন; প্রথমবার ব্রাউজারে Python (Pyodide) নামতে কয়েক সেকেন্ড লাগে।

from itertools import product

def charge(dhaka, big, member):        # the spec, written as code
    if dhaka:
        return 0 if big else 60
    return 60 if member else 120

full = {"".join("YN"[not v] for v in vals): charge(*vals)
        for vals in product([True, False], repeat=3)}
print("Full: 2^3 =", len(full), full)

def expand(rule):                       # "YN-" -> ["YNY", "YNN"]
    opts = [("Y", "N") if c == "-" else c for c in rule]
    return ["".join(p) for p in product(*opts)]

def merge_once(rules):        # same action, exactly 1 Y/N differs
    for a, b in product(rules, rules):
        d = [i for i in range(3) if a[i] != b[i]]
        if (a < b and rules[a] == rules[b] and len(d) == 1
                and "-" not in a[d[0]] + b[d[0]]):
            new = {r: x for r, x in rules.items() if r not in (a, b)}
            new[a[:d[0]] + "-" + a[d[0] + 1:]] = rules[a]
            return new
def check(name, rules):       # expand back and compare with full
    cols = [c for r in rules for c in expand(r)]
    bad = [c for r, x in rules.items() for c in expand(r) if full[c] != x]
    print(f"{name}: {len(rules)} rules, counts to {len(cols)},",
          f"missing {sorted(set(full) - set(cols))}, wrong {bad}")

rules = full
while (nxt := merge_once(rules)) is not None:
    rules = nxt
print("Collapsed:", dict(sorted(rules.items(), reverse=True)))
check("tool collapse", rules)
check("hand collapse", {"YY-": 0, "-N-": 60, "NY-": 120})

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

Full: 2^3 = 8 {'YYY': 0, 'YYN': 0, 'YNY': 60, 'YNN': 60, 'NYY': 60, 'NYN': 120, 'NNY': 60, 'NNN': 120}
Collapsed: {'YY-': 0, 'YN-': 60, 'N-Y': 60, 'N-N': 120}
tool collapse: 4 rules, counts to 8, missing [], wrong []
hand collapse: 3 rules, counts to 8, missing [], wrong ['NNN', 'NYY']

প্রথম লাইনে পূর্ণ টেবিলের আটটি কলাম, stepper-এর সাথে হুবহু মিল। Program-টির ছোট করা টেবিলেও ৪টি rule: YY-, YN-, N-Y, N-N. খুলে গুনলে ৮টি কলাম, কোনোটি বাদ নেই (missing []), কোনোটির উত্তর ভুল নয় (wrong [])। সহকর্মীর টেবিলও গুনে ৮, তাই শুধু rule-count দেখলে ঠিক মনে হতো। কিন্তু খুলে মেলাতেই দুটি ভুল বেরোল: “-N-” ধরে নিয়েছে ঢাকার বাইরে ছোট অর্ডারেও সবসময় 60, অথচ NNN-এর (সাধারণ ক্রেতা) উত্তর 120; আর “NY-” ধরে নিয়েছে বাইরে বড় অর্ডারে সবসময় 120, অথচ NYY-এর (সদস্য) উত্তর 60. দুটি ভুল মিশ্রণ একে অপরের ঘাটতি পূরণ করেছে বলেই গোনা মিলে গেছে।

মেশানোর এই কাজ Boolean algebra-র সরলীকরণের সাথে হুবহু এক: কলামগুলো যেন minterm, আর “−” যেন একটি চলক বাদ পড়া। ডিসক্রিট ম্যাথ কোর্সের পর্ব ৬৯-এ Quine–McCluskey পদ্ধতি ঠিক এভাবে এক ঘরে আলাদা পদ জোড়ায় জোড়ায় মেলায়। সেখান থেকে একটি শিক্ষা এখানেও খাটে: সবচেয়ে ছোট রূপ সবসময় একটি নয়, আর বড় টেবিলে সবচেয়ে ছোট রূপ খোঁজা কঠিন সমস্যা। আমাদের টেবিলে সবচেয়ে কম ৪টি rule, আর ৪টির রূপ একটিই (একটি scratch script সব সম্ভাব্য মেশানো খুঁজে এটি যাচাই করেছে)।

৫ · টেবিল থেকে test case আর coverage

প্রতিটি কলাম একটি coverage item. ISTQB-এর syllabus-এর ভাষা নিজের কথায় বললে: decision table testing-এ coverage item হলো টেবিলের প্রতিটি সম্ভব (feasible) কলাম, আর decision table coverage = test-এ অন্তত একবার চলা কলাম ÷ মোট সম্ভব কলাম × ১০০%. অসম্ভব কলাম হরে ধরা হয় না। পূর্ণ টেবিলের ৮টি কলাম থেকে ৮টি test case:

IDdistrictamountPlusexpectedcoverage item
TC1Dhaka2500Y0R1 YYY
TC2Dhaka2500N0R2 YYN
TC3Dhaka1500Y60R3 YNY
TC4Dhaka1500N60R4 YNN
TC5Rajshahi2500Y60R5 NYY
TC6Rajshahi2500N120R6 NYN
TC7Rajshahi1500Y60R7 NNY
TC8Rajshahi1500N120R8 NNN

ছোট করা টেবিল থেকে test বানালে লাগে ৪টি, আর প্রতিটি “−”-এর জায়গায় যেকোনো একটি মান বসাতে হয়। প্রশ্ন হলো, এতে কিছু হারায় কি না। উত্তর পেতে একটি ছোট code under test নিচ্ছি, যেখানে ইচ্ছা করে একটি defect রাখা আছে (seeded bug): developer সদস্যের নিয়মটি সবার আগে যাচাই করেছেন। তারপর একই test generator তিনভাবে চালাচ্ছি: ছোট টেবিল, “−” = N; ছোট টেবিল, “−” = Y; আর পূর্ণ টেবিল।

import io, sys, unittest

def delivery_charge(district, amount, member):  # code under test
    if member:                  # seeded defect: member rule checked first
        return 60
    if district == "Dhaka":
        return 0 if amount >= 2000 else 60
    return 120

COLLAPSED = {"YY-": 0, "YN-": 60, "N-Y": 60, "N-N": 120}
FULL = {"YYY": 0, "YYN": 0, "YNY": 60, "YNN": 60,
        "NYY": 60, "NYN": 120, "NNY": 60, "NNN": 120}

def inputs(rule):               # one concrete test input per column
    return ("Dhaka" if rule[0] == "Y" else "Rajshahi",
            2500 if rule[1] == "Y" else 1500, rule[2] == "Y")

def suite(name, table, fill):    # one test method per rule
    methods = {}
    for rule, want in table.items():
        r = rule.replace("-", fill)
        def test(self, r=r, want=want):
            self.assertEqual(delivery_charge(*inputs(r)), want)
        methods[f"test_{r}"] = test
    cls = type(name, (unittest.TestCase,), methods)
    return unittest.defaultTestLoader.loadTestsFromTestCase(cls)

quiet = unittest.TextTestRunner(stream=io.StringIO())
for fill in "NY":
    res = quiet.run(suite("Collapsed", COLLAPSED, fill))
    print(f"collapsed, '-' = {fill}: ran {res.testsRun},",
          f"failures {len(res.failures)}")
print("--- full table, 8 rules")
loud = unittest.TextTestRunner(stream=sys.stdout, verbosity=2)
loud.run(suite("Full", FULL, ""))

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

collapsed, '-' = N: ran 4, failures 0
collapsed, '-' = Y: ran 4, failures 1
--- full table, 8 rules
test_NNN (__main__.Full.test_NNN) ... ok
test_NNY (__main__.Full.test_NNY) ... ok
test_NYN (__main__.Full.test_NYN) ... ok
test_NYY (__main__.Full.test_NYY) ... ok
test_YNN (__main__.Full.test_YNN) ... ok
test_YNY (__main__.Full.test_YNY) ... ok
test_YYN (__main__.Full.test_YYN) ... ok
test_YYY (__main__.Full.test_YYY) ... FAIL

======================================================================
FAIL: test_YYY (__main__.Full.test_YYY)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "main.py", line 23, in test
    self.assertEqual(delivery_charge(*inputs(r)), want)
    ~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
AssertionError: 60 != 0

----------------------------------------------------------------------
Ran 8 tests in 0.001s

FAILED (failures=1)

তিনটি ফল পাশাপাশি পড়ুন। ছোট টেবিল, “−” = N: ৪টি test, একটিও ফেল নয়; ছোট টেবিলের coverage ১০০%, অথচ defect রয়ে গেছে। “−” = Y দিলে ১টি ফেল, কিন্তু সেটি ভাগ্য: কোন মান বসাবেন, তা আগে থেকে জানার উপায় ছিল না। পূর্ণ টেবিলের ৮টি test-এ শুধু test_YYY ফেল: ঢাকার ভেতরে ২৫০০ টাকার অর্ডার, Plus সদস্য। AssertionError: 60 != 0 পড়ুন এভাবে: কোড দিয়েছে 60 (actual), নিয়ম বলে 0 (expected). কোডের প্রথম if সদস্য দেখেই 60 ফেরত দেয়, ফলে ঢাকার ফ্রি delivery-র নিয়মে আর পৌঁছায় না।

“−” কিসের দাবি

Don't-care হলো requirement সম্পর্কে একটি দাবি: “এই rule-এ এই শর্তের প্রভাব নেই।” Black-box tester কোড দেখেন না, তাই কোডও যে শর্তটি উপেক্ষা করে, তা জানেন না। কোডের if-এর ক্রম অন্য রকম হলে ঠিক ওই উপেক্ষিত শর্তটিই ফল বদলে দিতে পারে। টাকা, নিরাপত্তা বা আইনের নিয়মে শর্ত কম হলে পূর্ণ টেবিল চালান। শর্ত বেশি হলে ছোট টেবিল নিন, আর ঝুঁকির জায়গায় “−”-এর দুটি মানই test করুন।

একটি পার্থক্য মনে রাখুন। Decision table coverage মাপে requirement-এর কলাম কতটা চলেছে। কোডের প্রতিটি if-এর সত্য আর মিথ্যা দুই দিক চলেছে কি না, তা আলাদা মাপ: decision বা branch coverage, যা white-box কৌশল, পর্ব ১৩ (White-box testing — statement, branch, condition আর MC/DC coverage)-এ। সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৫০-এ coverage-এর এসব মাপের সংক্ষিপ্ত পরিচয় আছে। উপরের defect-ওয়ালা কোডে ছোট টেবিলের ৪টি test প্রতিটি if-এর দুই দিকই চালায়, তবু defect ধরে না। এক ধরনের coverage আরেক ধরনের ঘাটতি ঢাকে না।

৬ · Requirement-এর ফাঁক আর বিরোধ ধরা

Decision table-এর সবচেয়ে বড় লাভ অনেক সময় test চালানোর আগেই আসে। ISTQB-এর syllabus-ও এই শক্তির কথা বলে: টেবিল ভরাতে গেলে requirement-এর ফাঁক আর বিরোধ চোখে পড়ে। ধরুন Plus সদস্যপদ চালুর আগে product owner (PO) প্রথম খসড়ায় এই পাঁচটি বাক্য লিখেছিলেন:

বাক্যখসড়ার ভাষাC1 C2 C3charge
D1ঢাকার ভেতরে, অর্ডার ২০০০-এর কম হলে ৬০ টাকাY N −60
D2ঢাকার ভেতরে, অর্ডার ২০০০ বা বেশি হলে ফ্রিY Y −0
D3ঢাকার বাইরে, অর্ডার ২০০০-এর কম, সাধারণ ক্রেতা: ১২০ টাকাN N N120
D4ঢাকার বাইরে Plus সদস্যের charge ৬০ টাকাN − Y60
D5Plus সদস্যের ২০০০ বা বেশি অর্ডারে delivery ফ্রি− Y Y0

প্রতিটি বাক্য আলাদাভাবে পড়লে যুক্তিসংগত। এবার ৮টি কলামের প্রতিটির জন্য দেখি কয়টি বাক্য খাটে। তিন রকম সমস্যা হতে পারে: কোনো বাক্যই খাটে না (ফাঁক), দুটি বাক্য খাটে কিন্তু উত্তর আলাদা (বিরোধ), আর দুটি বাক্য খাটে, উত্তরও এক (ক্ষতিহীন overlap, তবে পরে একটি বাক্য বদলালে বিরোধে পরিণত হতে পারে)।

প্রতিটি কলামে কোন বাক্য খাটে
কলাম
বাক্য
রায়
  1. বাক্যকে pattern বানানো। প্রতিটি বাক্যকে C1 C2 C3-এর pattern-এ লেখা হলো। যে শর্তের কথা বাক্যে নেই, সেখানে “−”। যেমন D5 ঠিকানার কথা বলে না, তাই তার pattern -YY.
  2. YYY: দুটি বাক্য, একই উত্তর। ঢাকার ভেতরে, বড় অর্ডার, সদস্য: D2 বলে ফ্রি, D5-ও বলে ফ্রি। আজ সমস্যা নেই। কিন্তু কাল কেউ D2 বদলালে D5 চুপচাপ পুরোনো উত্তর ধরে রাখবে। নথিতে চিহ্ন দিয়ে রাখার মতো।
  3. তিনটি পরিষ্কার কলাম। YYN-এ শুধু D2, YNY আর YNN-এ শুধু D1. প্রতিটিতে ঠিক একটি বাক্য, তাই উত্তর নিয়ে সন্দেহ নেই।
  4. NYY: বিরোধ। ঢাকার বাইরে, বড় অর্ডার, সদস্য। D4 বলে ৬০ টাকা, D5 বলে ফ্রি। Developer যে if আগে লিখবেন, সেটিই জিতবে। এটি আর কোডের প্রশ্ন নয়, ব্যবসার সিদ্ধান্ত।
  5. NYN: ফাঁক। ঢাকার বাইরে, বড় অর্ডার, সাধারণ ক্রেতা। D3 শুধু “২০০০-এর কম” বলেছে, D4 আর D5 সদস্যের কথা। এই ক্রেতার charge কোথাও লেখা নেই। Developer আন্দাজে কিছু একটা লিখবেন, আর tester-এর হাতে প্রত্যাশিত ফলই থাকবে না।
  6. শেষ দুটি আর সিদ্ধান্ত। NNY-এ D4, NNN-এ D3, দুটোই ঠিক। মোট দুটি প্রশ্ন গেল PO-র কাছে। উত্তর এলো: D5 বাদ (সদস্যের বাড়তি সুবিধা শুধু ঢাকার বাইরের ৬০ টাকা), আর NYN = ১২০. এভাবেই তৈরি হলো §১-এর চূড়ান্ত নিয়ম।

এই খোঁজাখুঁজিও যন্ত্রে করা যায়। নিচের program প্রতিটি বাক্যকে pattern হিসেবে রাখে, আর প্রতিটি কলামে কোন বাক্য মেলে তা দেখে রায় দেয়:

from itertools import product

# Draft requirement, one line per sentence the product owner wrote.
# Columns: C1 inside Dhaka, C2 order >= 2000, C3 Plus member.
DRAFT = {
    "D1 Dhaka, under 2000: 60":           ("YN-", 60),
    "D2 Dhaka, 2000 or more: free":        ("YY-", 0),
    "D3 outside, under 2000, normal: 120": ("NNN", 120),
    "D4 outside, Plus member: 60":         ("N-Y", 60),
    "D5 Plus member, 2000 or more: free":  ("-YY", 0),
}

def matches(pattern, col):
    return all(p in ("-", c) for p, c in zip(pattern, col))

problems = 0
for col in ("".join(p) for p in product("YN", repeat=3)):
    hits = [(name[:2], act) for name, (pat, act) in DRAFT.items()
            if matches(pat, col)]
    acts = {act for _, act in hits}
    if not hits:
        verdict = "MISSING - no sentence covers this case"
    elif len(acts) > 1:
        verdict = "CONTRADICTION - different answers"
    elif len(hits) > 1:
        verdict = "overlap, same answer (harmless)"
    else:
        verdict = "ok"
    problems += verdict.startswith(("MISSING", "CONTRA"))
    print(f"{col}: {hits} {verdict}")
print("columns needing a question to the owner:", problems)

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

YYY: [('D2', 0), ('D5', 0)] overlap, same answer (harmless)
YYN: [('D2', 0)] ok
YNY: [('D1', 60)] ok
YNN: [('D1', 60)] ok
NYY: [('D4', 60), ('D5', 0)] CONTRADICTION - different answers
NYN: [] MISSING - no sentence covers this case
NNY: [('D4', 60)] ok
NNN: [('D3', 120)] ok
columns needing a question to the owner: 2

Stepper-এর সাথে হুবহু মিল: NYY-এ বিরোধ (D4 বলে 60, D5 বলে 0), NYN-এ ফাঁক, YYY-তে ক্ষতিহীন overlap. শেষ লাইনের ২টি প্রশ্ন কোড লেখার আগেই PO-র কাছে যাওয়ার কথা। খেয়াল করুন, এটি static testing: কিছুই চালানো হয়নি, শুধু requirement-কে টেবিলের রূপে পড়া হয়েছে। Rule-count দিয়েও আভাস পাওয়া যেত: খসড়ার pattern-গুলো গোনে 2 + 2 + 1 + 2 + 2 = ৯, যা ৮-এর বেশি, তাই কোথাও overlap আছে; কিন্তু একই সাথে একটি ফাঁকও যে আছে, তা কলাম ধরে না দেখলে বোঝা যেত না।

পর্ব ০৬ (Static testing — review, walkthrough, inspection আর static analysis)-এ review-এর পদ্ধতি আছে; decision table সেই review-এর একটি ধারালো হাতিয়ার। বিরোধ ধরার কাজটি বড় আকারে করে SAT solver: বাক্যগুলোকে যুক্তির সূত্র বানিয়ে “এমন কোনো ইনপুট কি আছে যেখানে দুটি নিয়ম একসাথে খাটে আর উত্তর আলাদা?” প্রশ্নটি যন্ত্রকে করা যায়। ডিসক্রিট ম্যাথ কোর্সের পর্ব ৭৭-এ এমন যাচাই হাতে-কলমে আছে।

৭ · অসম্ভব মিশ্রণ, extended entry আর বড় টেবিল

এবার coupon. নিয়ম একটি সংখ্যা থেকে আসে (অর্ডারের পরিমাণ), কিন্তু দুটি প্রশ্ন তোলে: অর্ডার ১০০০-এর বেশি কি না (ছাড় আছে কি না), আর ১০% হিসাবে ছাড় ৩০০ বা বেশি হয় কি না, অর্থাৎ অর্ডার ৩০০০ বা বেশি (সর্বোচ্চ সীমা খাটে কি না)। দুটি Y/N শর্তে ৪টি কলাম, কিন্তু একটি অসম্ভব:

শর্ত / কাজR1R2R3R4
C1 অর্ডার > 1000YYNN
C2 অর্ডার ≥ 3000YNYN
A1 ছাড় (টাকা)300অর্ডারের 10%, ভগ্নাংশ বাদঅসম্ভব0

R3 বলে “অর্ডার ১০০০ বা কম, অথচ ৩০০০ বা বেশি”। এমন অর্ডার হয় না। এটি একটি infeasible (অসম্ভব) কলাম। টেবিলে একে “অসম্ভব” বা N/A লিখে রাখুন, মুছে দেবেন না, যাতে পাঠক বোঝেন কলামটি ভুলে বাদ পড়েনি। এর test হয় না, আর coverage-এর হরেও এটি ধরা হয় না: এখানে সম্ভব কলাম ৩টি, তাই ৩টি test-এ ১০০%.

অসম্ভব কলামের সংখ্যা বাড়ে দ্রুত। পুরো checkout-এর হিসাবে অর্ডারের পরিমাণ থেকেই তিনটি শর্ত আসে (১০০০-এর বেশি, ২০০০ বা বেশি, ৩০০০ বা বেশি), সাথে ঠিকানা আর সদস্যপদ। পাঁচটি Y/N শর্তে 25 = ৩২টি কলাম, যার মধ্যে সম্ভব মাত্র ১৬টি: অর্ডারের তিনটি শর্তের ৮টি মিশ্রণের মধ্যে বাস্তবে আসে শুধু NNN, YNN, YYN, YYY (একটি script ০ থেকে ৬০০০ টাকার প্রতিটি অর্ডার পরীক্ষা করে এটি গুনেছে)। এর পরিষ্কার সমাধান extended entry: তিনটি নির্ভরশীল Y/N শর্তের বদলে একটি চার-মানের শর্ত, “অর্ডারের দল”: ≤1000, 1001–1999, 2000–2999, ≥3000. তখন 4 × 2 × 2 = ১৬টি কলাম, একটিও অসম্ভব নয়।

কিন্তু extended entry একটি নতুন প্রশ্ন তোলে: প্রতিটি দল থেকে কোন অর্ডারের মানটি নেবেন? নিচের program মোট বিল (অর্ডার − ছাড় + delivery charge) পরীক্ষা করে। Code under test-এ একটি seeded defect আছে: developer ফ্রি delivery-র শর্তে ছাড়ের পরের অঙ্ক ধরেছেন, অথচ নিয়মে অর্ডার মানে ছাড়ের আগের দাম। একই ১৬টি rule দুইভাবে চালানো হচ্ছে: প্রতিটি দলের মাঝের একটি মান নিয়ে, আর প্রতিটি দলের সবচেয়ে ছোট মান নিয়ে।

import io, unittest
from itertools import product

def coupon(amount):                       # spec: >1000 -> 10%, max 300
    return min(amount // 10, 300) if amount > 1000 else 0

def payable(amount, dhaka, member):       # code under test
    off = coupon(amount)
    if dhaka:   # seeded defect: free-delivery check uses the discounted sum
        fee = 0 if amount - off >= 2000 else 60
    else:
        fee = 60 if member else 120
    return amount - off + fee

def spec_fee(band, dhaka, member):       # action row of the table
    if dhaka:
        return 0 if band in ("2000-2999", ">=3000") else 60
    return 60 if member else 120

BANDS = {"<=1000": (500, 1000), "1001-1999": (1500, 1001),
         "2000-2999": (2500, 2000), ">=3000": (4000, 3000)}
rules = list(product(BANDS, [True, False], [True, False]))
print("extended-entry rules: 4 x 2 x 2 =", len(rules))

for pick, label in ((0, "middle of band"), (1, "lowest value")):
    T = type("Checkout", (unittest.TestCase,), {})
    for i, (band, d, m) in enumerate(rules):
        a = BANDS[band][pick]
        want = a - coupon(a) + spec_fee(band, d, m)
        setattr(T, f"test_{i:02}", lambda s, a=a, d=d, m=m, w=want:
                s.assertEqual(payable(a, d, m), w))
    r = unittest.TextTestRunner(stream=io.StringIO()).run(
        unittest.defaultTestLoader.loadTestsFromTestCase(T))
    print(f"{label}: ran {r.testsRun}, failed {len(r.failures)}",
          [f.splitlines()[-1] for _, f in r.failures])

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

extended-entry rules: 4 x 2 x 2 = 16
middle of band: ran 16, failed 0 []
lowest value: ran 16, failed 2 ['AssertionError: 1860 != 1800', 'AssertionError: 1860 != 1800']

দুই বারই ১৬টি rule চলেছে, decision table coverage দুই বারই ১০০%. কিন্তু দলের মাঝের মান (২৫০০) নিলে defect লুকিয়ে থাকে: ২৫০০ − ২৫০ = ২২৫০, যা এখনো ২০০০-এর বেশি, তাই ভুল কোডও ফ্রি দেয়। দলের সবচেয়ে ছোট মান (২০০০) নিলে ২০০০ − ২০০ = ১৮০০, ভুল কোড ৬০ টাকা বসায়: মোট ১৮৬০, নিয়মে ১৮০০. দুটি ফেল-ই ঢাকার ভেতরের দুটি rule (সদস্য আর সাধারণ)। একটি scratch script গুনে দেখেছে, এই defect ধরা পড়ে শুধু ২০০০ থেকে ২২২১ টাকার অর্ডারে, মোট ২২২টি মানে। শিক্ষা: decision table বলে কোন মিশ্রণ test করবেন; প্রতিটি মিশ্রণের ভেতরে কোন মান নেবেন, তা বলে boundary value analysis. দুটি একসাথে লাগে।

বড় টেবিলের জন্য আরও তিনটি কৌশল:

  • টেবিল ভাঙা: আগে “ছাড় কত” (২টি শর্ত), তারপর “delivery কত” (৩টি শর্ত), শেষে “মোট বিল” শুধু যোগ-বিয়োগ। দুটি ছোট টেবিলে মোট ৪ + ৮ = ১২টি কলাম, এক বড় টেবিলের ১৬-এর জায়গায়, আর প্রতিটি পড়া সহজ। তবে উপরের defect-এর মতো দুই টেবিলের সংযোগের ভুল ধরতে মোট বিলের কয়েকটি test লাগবেই।
  • শর্ত পরস্পর স্বাধীন হলে, আর প্রতিটি মিশ্রণের আলাদা যুক্তি না থাকলে (যেমন browser, ভাষা, payment method কোনো নিয়মে যুক্ত নয়), decision table নয়, pairwise testing ভালো: পর্ব ১১ (Pairwise আর combinatorial testing — কম test-এ বেশি মিশ্রণ)।
  • ঝুঁকি দিয়ে বাছাই: সব কলাম সমান গুরুত্বপূর্ণ নয়। টাকা বা আইনের কলাম আগে, বিরল মিশ্রণ পরে; বাদ দিলে কেন বাদ দিলেন, test plan-এ লিখে রাখুন।

৮ · Cause-effect graph — শর্ত থেকে ফল পর্যন্ত যুক্তির ছবি

Requirement যখন লম্বা গদ্যে লেখা, তখন সরাসরি টেবিল বানানো কঠিন। Cause-effect graph মাঝখানে একটি ধাপ যোগ করে: আগে কারণ (cause, অর্থাৎ input-এর শর্ত) আর ফল (effect, অর্থাৎ output বা কাজ) আলাদা করে লেখা, তারপর তাদের যুক্তির সম্পর্ক AND (∧), OR (∨) আর NOT (¬) দিয়ে আঁকা। আমাদের delivery নিয়মের graph:

Delivery charge-এর cause-effect graph

বাঁয়ে কারণ, ডানে ফল; লাল ড্যাশ রেখা মানে NOT

Cause-effect graph for the delivery charge rule c1 ঢাকা c2 ≥ ২০০০ c3 Plus e1 ফ্রি e2 ৬০ টাকা e3 ১২০ টাকা ∧∧∧∧∨ লাল ড্যাশ = NOT · ফলে বাধা O: ঠিক একটি
ছবি ৯.২ — e1 = c1 ∧ c2; e2 = (c1 ∧ ¬c2) ∨ (¬c1 ∧ c3); e3 = ¬c1 ∧ ¬c3. প্রতিটি ফল থেকে পেছনে হেঁটে, কোন কারণ-মিশ্রণে ফলটি সত্য হয় তা লিখলেই decision table-এর কলাম পাওয়া যায়।

Myers-এর বইয়ে graph-এ কারণের মধ্যে কিছু বাধাও (constraint) আঁকা হয়, যাতে অসম্ভব মিশ্রণ আগেই বাদ পড়ে: E (exclusive, একসাথে সর্বোচ্চ একটি সত্য), I (inclusive, অন্তত একটি সত্য), O (one and only one, ঠিক একটি সত্য), R (requires, একটি সত্য হলে অন্যটিও সত্য হতে হবে); আর ফলের ওপর M (masks, একটি ফল ঘটলে অন্যটি ঘটে না)। Coupon-এর দুটি শর্তে “অর্ডার ≥ 3000” সত্য হলে “অর্ডার > 1000”-ও সত্য, অর্থাৎ R বাধা; এটিই §৭-এর অসম্ভব কলামটিকে graph-এর স্তরেই বাদ দেয়। আর ছবির তিনটি ফলের মধ্যে ঠিক একটি ঘটে, তাই সেখানে O চিহ্ন।

বাস্তবে আজ পূর্ণ cause-effect graph খুব কম দল আঁকে; বড় graph আঁকা সময়সাপেক্ষ, আর এর জন্য বহুল ব্যবহৃত tool-ও কম। কিন্তু ভাবনার কাঠামোটি খুব কাজের: “কারণ কী কী, ফল কী কী, আর কোন মিশ্রণ অসম্ভব?” এই তিন প্রশ্নের উত্তর লিখলেই টেবিল প্রায় তৈরি। যুক্তির চিহ্নগুলো (∧, ∨, ¬) ডিসক্রিট ম্যাথ কোর্সের পর্ব ০২-এর truth table-এর সাথে একই জিনিস; decision table আসলে ফলের নাম লেখা একটি truth table.

যে ফাঁদগুলো বারবার দেখা যায়

  • প্রত্যাশিত ফল কোড থেকে নেওয়া। কাজের সারি কোড চালিয়ে ভরালে টেবিল ভুল কোডকেই “ঠিক” বলে পাকা করে। সারিটি ভরবে শুধু requirement থেকে।
  • “−”-কে নিশ্চয়তা ভাবা। §৫-এর মতো, ছোট টেবিলের ১০০% coverage-এও defect থাকতে পারে।
  • Rule-count মিললেই নিশ্চিন্ত হওয়া। §৪-এর সহকর্মীর টেবিল গুনে ৮ ছিল, তবু দুটি কলামের উত্তর ভুল।
  • সংখ্যার শর্তের সীমা ভুলে যাওয়া। “২০০০ বা বেশি” শর্তের Y-দলে ২০০০ নিজেও আছে; প্রতিনিধি মান সীমায় না নিলে > বনাম >= ধরনের ভুল ফসকে যায় (পর্ব ০৮)।
  • অসম্ভব কলাম মুছে ফেলা, ফলে পাঠক ভাবেন কলামটি ভুলে বাদ পড়েছে। “অসম্ভব” লিখে রাখুন।
  • এক টেবিলে সব কিছু। সাত-আটটি শর্তের টেবিল কেউ review করতে পারে না। ভাঙুন।

আরও গভীরে: ব্যবসায়িক নিয়ম লেখার একটি মান আছে, OMG-র Decision Model and Notation (DMN), যার প্রথম সংস্করণ ২০১৫ সালের দিকে প্রকাশিত। DMN-এর decision table-এ প্রতিটি টেবিলের একটি hit policy থাকে: Unique (প্রতিটি ইনপুটে ঠিক একটি rule খাটবে), First (প্রথম মেলা rule জিতবে), Priority, Collect ইত্যাদি। §৬-এর বিরোধ আর ফাঁক ঠিক এই policy-র লঙ্ঘন, আর কিছু DMN tool টেবিল সংরক্ষণের সময়ই এগুলো জানায়। বড় টেবিলে সবচেয়ে ছোট ছোট-করা রূপ খোঁজা Boolean minimization-এর সমস্যা, যা সাধারণভাবে কঠিন; তাই tool-গুলো সাধারণত “যথেষ্ট ছোট” রূপ দেয়, সবসময় সবচেয়ে ছোট নয়।

পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এমন প্রশ্ন খুব চেনা:

  • ৪টি Y/N শর্তে পূর্ণ decision table-এ কয়টি rule? — 24 = ১৬; একটি শর্তের ৩টি মান থাকলে 23 × 3 = ২৪.
  • ছোট টেবিলের rule-গুলোতে “−”-এর সংখ্যা 0, 1, 1, 2; ৩টি শর্ত। টেবিল সম্পূর্ণ? — 1 + 2 + 2 + 4 = ৯ ≠ ৮, তাই অন্তত একটি মিশ্রণ দুটি rule-এ ঢুকেছে; খুলে দেখতে হবে।
  • ৮টি কলামের ২টি অসম্ভব, test চলেছে ৫টি সম্ভব কলামে। Coverage কত? — ৫ ÷ ৬ ≈ ৮৩.৩%; অসম্ভব কলাম হরে নেই।
  • Decision table কখন, pairwise কখন? — শর্তগুলোর মিশ্রণে আলাদা যুক্তি (নিয়ম) থাকলে decision table; স্বাধীন configuration-এর মান মেশাতে pairwise.
  • Cause-effect graph-এ E, I, O, R, M কী? — Exclusive, Inclusive, One-and-only-one, Requires (কারণের বাধা) আর Masks (ফলের বাধা)।

৯ · AI-এর যুগে decision table

AI assistant-কে একটি নিয়ম দিয়ে “একটি decision table বানিয়ে দিন” বললে কয়েক সেকেন্ডে সুন্দর একটি টেবিল আসে। কিন্তু পরীক্ষা করে দেখা যায় কিছু ভুল বারবার ঘটে। কলাম গুনতে ভুল হয়, বিশেষ করে extended entry-তে। ছোট করার সময় এমন দুটি কলাম মেশায় যাদের উত্তর আলাদা, ঠিক §৪-এর সহকর্মীর মতো। Requirement-এ যে কলামের উত্তর নেই, সেখানে প্রশ্ন না তুলে নিজেই একটি “যুক্তিসংগত” উত্তর বসিয়ে দেয়, ফলে ফাঁকটি চাপা পড়ে। কোড দেওয়া থাকলে প্রত্যাশিত ফল প্রায়ই কোড পড়ে বসায়, তখন test ভুল কোডেও পাস করে। Test লিখতে বললে শুধু সহজ পথের (happy path) কয়েকটি কলাম নেয়, সীমার মান বাদ দেয়, আর চালানো ছাড়াই বলে “সব test পাস”। কখনো ISTQB-এর নামে এমন সংজ্ঞা বা DMN-এর এমন hit policy বলে, যা সেখানে নেই।

AI-কে টেবিল বানাতে দিলে requirement সরাসরি দিন, কোড নয়, আর তাকে ফাঁক খুঁজতে বলুন:

নিচের requirement থেকে একটি limited-entry decision table বানান। কোড দেখে প্রত্যাশিত ফল ঠিক করবেন না। Requirement: ঢাকার ভেতরে delivery charge ৬০ টাকা, বাইরে ১২০ টাকা। অর্ডার ২০০০ টাকা বা বেশি হলে ঢাকার ভেতরে ফ্রি। Plus সদস্যের ঢাকার বাইরের charge ৬০ টাকা। ১. প্রথমে শর্ত আর কাজের তালিকা দিন, তারপর মোট কলামের সংখ্যা আর তার হিসাব। ২. পূর্ণ টেবিল দিন; যে কলামের উত্তর requirement-এ নেই বা দুই রকম, সেখানে উত্তর না বসিয়ে "প্রশ্ন" লিখুন। ৩. ছোট করা টেবিল দিন, আর প্রতিটি "−" খুলে দেখান যে উত্তর বদলায় না। ৪. প্রতিটি কলাম থেকে একটি test case দিন: ইনপুট, প্রত্যাশিত ফল, কোন কলাম। ৫. Test চালিয়েছেন বলে দাবি করবেন না; আমি নিজে চালাব।

AI-এর বানানো decision table আর test হাতে পেলে — যাচাইয়ের চেকলিস্ট

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

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

প্র ০১Decision table তো ১৯৬০-এর দশকে program লেখার পদ্ধতি ছিল। আজ testing-এ সেটি কেন টিকে আছে, আর program লেখায় কেন হারিয়ে গেল?

১৯৫০ আর ১৯৬০-এর দশকে ব্যবসায়িক data processing-এর program-গুলো ছিল নিয়মে ভরা: বেতন, বিমা, ব্যাংকের সুদ। Flowchart-এ এমন নিয়ম আঁকলে ডালপালা ছড়িয়ে পড়ত, আর কোন মিশ্রণ বাদ পড়েছে বোঝা যেত না। Decision table সেখানে একটি সমাধান ছিল: নিয়ম টেবিলে লেখা হবে, আর একটি অনুবাদক টেবিল থেকে কোড বানাবে। আমাদের জানামতে CODASYL-এর একটি দল ১৯৬২ সালের দিকে DETAB-X নামে এমন একটি ভাষার প্রস্তাব দিয়েছিল, আর পরের বছরগুলোতে বিভিন্ন decision table preprocessor তৈরি হয়।

Program লেখার মূল ধারায় পদ্ধতিটি টেকেনি। Structured programming-এর if/else, পরে object-oriented নকশা আর rule engine নিয়মের যুক্তি অন্যভাবে প্রকাশ করতে শুরু করে। বড় টেবিল রক্ষণাবেক্ষণও কঠিন ছিল; একটি শর্ত যোগ হলে কলাম দ্বিগুণ।

Testing-এ টিকে থাকার কারণ ভিন্ন। Tester-এর কাছে টেবিলটি কোড নয়, একটি চেকলিস্ট আর oracle: কোন মিশ্রণ test হয়েছে, আর প্রতিটিতে উত্তর কী হওয়ার কথা। এই কাজে টেবিলের দুর্বলতা (বড় হয়ে যাওয়া) আসলে শক্তি, কারণ তা মিশ্রণের সংখ্যা চোখের সামনে আনে। Glenford Myers ১৯৭৯ সালের বইয়ে cause-effect graph থেকে টেবিল আর test বের করার পদ্ধতি দেখান, আর পরের দশকগুলোতে test design-এর পাঠ্যবই আর ISTQB-এর syllabus এটিকে মূল black-box কৌশলের তালিকায় রাখে।

মজার ব্যাপার, নিয়মের টেবিল program-এও আংশিক ফিরে এসেছে: আজকের business rule engine আর DMN-এর decision table আবার নিয়ম টেবিলে লেখে, আর tool সেটি সরাসরি চালায়। তখন tester-এর কাজ বদলায়: টেবিলটিই এখন “কোড”, তাই তার ফাঁক আর বিরোধ খোঁজা মানে সরাসরি defect খোঁজা।

মূল উপলব্ধি: একটি নকশা-পদ্ধতি এক কাজে অচল হয়েও অন্য কাজে অমূল্য হতে পারে। Decision table কোড লেখার জন্য ভারী, কিন্তু “কোন মিশ্রণ বাদ পড়ল?” প্রশ্নের উত্তর দিতে এখনো সবচেয়ে সরল হাতিয়ার।

প্র ০২ছোট করা টেবিলের সব কলাম test হলো, coverage ১০০%. তবু defect ফসকে গেল। তাহলে কি সবসময় পূর্ণ টেবিল চালানো উচিত?

না, তবে “−” কোথায় নিরাপদ, তা বিচার করে নিতে হয়। ছোট করা টেবিল একটি মডেল-সংকোচন: requirement বলছে কিছু শর্ত কিছু rule-এ প্রভাব ফেলে না। কোড যদি requirement-এর হুবহু গঠন মানে, তাহলে ছোট টেবিলের test যথেষ্ট। কিন্তু কোডের if-এর ক্রম আলাদা হলে উপেক্ষিত শর্তটিই ফল বদলে দিতে পারে, ঠিক যেমন §৫-এর code-এ সদস্যের যাচাই আগে আসায় ঢাকার ফ্রি delivery হারিয়ে গেল।

খরচের হিসাবটি সোজা। ৩টি শর্তে পূর্ণ টেবিল ৮টি test, ছোট ৪টি; পার্থক্য সামান্য, তাই টাকার নিয়মে পূর্ণ টেবিলই ভালো। ১০টি শর্তে পূর্ণ টেবিল ১০২৪টি, তখন সব চালানো প্রায়ই অবাস্তব। মাঝামাঝি কিছু পথ আছে: “−”-এর জায়গায় একবার Y আর একবার N দুটোই নেওয়া; ঝুঁকির কলামগুলো খুলে পূর্ণ রাখা; আর যে শর্তগুলো কোডে একই if-এ জোড়া, সেগুলোর মিশ্রণে বেশি জোর দেওয়া।

একই প্রশ্ন বিমান-শিল্পে আরও কঠোরভাবে উঠেছিল। বিমানের software-এর নির্দেশিকা DO-178B (১৯৯২) আর তার উত্তরসূরি DO-178C (২০১১) সবচেয়ে ঝুঁকিপূর্ণ (Level A) software-এর জন্য MC/DC coverage চায়: একটি যৌগিক সিদ্ধান্তের প্রতিটি শর্তকে আলাদাভাবে দেখাতে হয় যে সেটি একা বদলালে ফল বদলায়। n-টি শর্তে পূর্ণ মিশ্রণ 2n, অথচ MC/DC সাধারণত n + 1টি test-এ পূরণ হয়। অর্থাৎ নিরাপত্তা-সচেতন শিল্পও “সব মিশ্রণ” চায় না, বরং চায় প্রতিটি শর্তের প্রভাব প্রমাণিত হোক। MC/DC পর্ব ১৩-এ বিস্তারিত।

Tester-এর জন্য বাস্তব নিয়ম: ছোট টেবিল নিলে test নথিতে লিখুন কোন “−”-এ কোন মান বসিয়েছেন, যাতে পরে defect এলে বোঝা যায় কোন মিশ্রণ চলেনি।

মূল উপলব্ধি: Coverage সবসময় একটি মডেলের সাপেক্ষে। মডেল ছোট করলে coverage সহজে ১০০% হয়, কিন্তু মডেলের বাইরে যা আছে তা চোখের আড়ালে চলে যায়।

প্র ০৩Cause-effect graph ১৯৭০-এর দশকে এত গুরুত্ব পেয়েছিল, অথচ আজ খুব কম দল পুরোটা আঁকে। কেন?

পদ্ধতিটির শিকড় IBM-এ। প্রচলিত বিবরণ অনুযায়ী William Elmendorf ১৯৭০-এর দশকের শুরুতে সেখানে functional testing-এ cause-effect graph ব্যবহারের পদ্ধতি লেখেন, আর Glenford Myers ১৯৭৯ সালে “The Art of Software Testing” বইয়ে এটিকে বিস্তারিত পদ্ধতি হিসেবে পরিচিত করান। ধারণাটি ছিল আকর্ষণীয়: প্রাকৃতিক ভাষার specification থেকে কারণ আর ফল আলাদা করা, যুক্তির graph আঁকা, বাধা (E, I, O, R, M) দিয়ে অসম্ভব মিশ্রণ বাদ দেওয়া, তারপর graph থেকে যান্ত্রিকভাবে decision table আর test বের করা।

আজ পুরো পদ্ধতি কম চলার কয়েকটি কারণ বোঝা যায়। প্রথমত, শ্রম: মাঝারি একটি নিয়মেও graph দ্রুত জট পাকায়, আর requirement বদলালে graph নতুন করে আঁকতে হয়। দ্বিতীয়ত, tool: এর জন্য বহুল ব্যবহৃত, সক্রিয়ভাবে রক্ষণাবেক্ষণ হওয়া tool কম; হাতে আঁকা graph আর কোডের মধ্যে যোগসূত্র রাখা কঠিন। তৃতীয়ত, কাজের ধরন বদলেছে: agile দলে requirement আসে ছোট user story আর acceptance criteria হিসেবে, যেখানে সরাসরি একটি ছোট decision table বা Given-When-Then উদাহরণের তালিকাই যথেষ্ট।

তবু ধারণাটি হারায়নি, অন্য রূপে বেঁচে আছে। Requirement থেকে “কারণ” আর “ফল” আলাদা করা আজও ভালো review-এর অংশ। বাধার ধারণা (একটি শর্ত আরেকটিকে অসম্ভব করে) আধুনিক combinatorial testing tool-এ “constraint” হিসেবে আছে, যা পর্ব ১১-এ দেখবেন। আর graph-এর যুক্তি আসলে Boolean সূত্র, যা আজ SAT solver দিয়ে স্বয়ংক্রিয়ভাবে বিশ্লেষণ করা যায়; সেখানে মানুষকে ছবি আঁকতে হয় না।

পরীক্ষার দিক থেকে মনে রাখার মতো: কারণ মানে input-এর শর্ত, ফল মানে output বা কাজ; প্রতিটি ফল থেকে পেছনে হেঁটে সেটি সত্য করার কারণ-মিশ্রণ বের করলে টেবিলের কলাম পাওয়া যায়।

মূল উপলব্ধি: একটি পদ্ধতির সব আচার না টিকলেও তার মূল চিন্তা টিকে থাকতে পারে। “কারণ কী, ফল কী, কোন মিশ্রণ অসম্ভব” এই তিন প্রশ্ন আজও যেকোনো নিয়মের test-এর শুরু।

প্র ০৪Requirement-এর ফাঁক আর বিরোধ tester কেন ধরবেন, product owner বা developer কেন নয়? আর বড় নিয়ম-ব্যবস্থায় এটি কীভাবে যন্ত্রে করা যায়?

Product owner নিয়ম লেখেন ব্যবসার চোখে: প্রতিটি বাক্য একটি নির্দিষ্ট পরিস্থিতির কথা ভেবে লেখা (“সদস্যদের বড় অর্ডারে ফ্রি করে দিই”)। প্রতিটি বাক্য আলাদাভাবে যুক্তিসংগত, কিন্তু বাক্যগুলোর মিশ্রণ কেউ পুরোটা দেখেন না। Developer দেখেন কোডের চোখে: তিনি একটি if-এর ক্রম বেছে নেন, আর সেই ক্রমই নীরবে বিরোধের মীমাংসা করে দেয়, কাউকে না জানিয়ে। §৬-এর NYY কলামে কোন বাক্য জিতবে, তা নির্ভর করত developer কোন লাইন আগে লিখতেন তার ওপর। ব্যবসার একটি সিদ্ধান্ত কোডের লাইনের ক্রমে লুকিয়ে যেত।

Tester-এর চোখ তৃতীয় রকম: “প্রতিটি মিশ্রণে উত্তর কী?” এই প্রশ্ন ছাড়া test-এর প্রত্যাশিত ফলই লেখা যায় না, তাই ফাঁক tester-এর কাছেই প্রথম স্পষ্ট হয়। এজন্যই testing-এর নীতি “যত আগে, তত ভালো” এখানে খুব বাস্তব: requirement-এর review-তে টেবিল আঁকলে দুটি প্রশ্ন এক মিটিংয়ে মিটে যায়; কোড আর release-এর পরে একই প্রশ্ন ক্রেতার অভিযোগ হয়ে আসে।

বড় ব্যবস্থায় হাতে সব কলাম দেখা অসম্ভব। তখন দুটি যান্ত্রিক পথ আছে। একটি DMN-এর মতো মান: টেবিলের hit policy “Unique” হলে tool যাচাই করতে পারে কোনো ইনপুটে দুটি rule খাটে কি না, আর কোনো ইনপুট কোনো rule-এ পড়ে না কি না। আরেকটি SAT বা SMT solver: প্রতিটি rule-এর শর্তকে যুক্তির সূত্র বানিয়ে solver-কে জিজ্ঞেস করা হয়, “এমন ইনপুট আছে কি যেখানে rule i আর rule j দুটোই সত্য অথচ ফল আলাদা?” উত্তর হ্যাঁ হলে solver একটি নির্দিষ্ট উদাহরণ দেয়, যা সরাসরি একটি test case. সংখ্যার শর্ত (অর্ডার ≥ ২০০০) থাকলে SMT solver সেটিও সামলায়।

তবু যন্ত্র শুধু বলতে পারে “এখানে ফাঁক বা বিরোধ আছে”। কোন উত্তর ঠিক, সেটি ব্যবসার সিদ্ধান্ত, তাই প্রশ্নটি শেষ পর্যন্ত মানুষের কাছেই যায়।

মূল উপলব্ধি: নিয়মের মিশ্রণে প্রতিটি উত্তর কারও না কারও সিদ্ধান্ত। Tester-এর কাজ নিশ্চিত করা যে সেই সিদ্ধান্ত সচেতনভাবে নেওয়া হয়েছে, কোডের লাইনের ক্রমে দুর্ঘটনাক্রমে নয়।

প্র ০৫Decision table কি শুধু নথি, নাকি সেটিই চালানো যায় এমন test হতে পারে? আর শর্ত খুব বেশি হলে কী করবেন?

টেবিলকে সরাসরি test বানানোর ধারণা পুরোনো। ২০০২ সালের দিকে Ward Cunningham FIT (Framework for Integrated Test) তৈরি করেন, যেখানে ব্যবসার লোকেরা HTML বা wiki-র টেবিলে উদাহরণ লেখেন (এই ইনপুটে এই ফল), আর ছোট একটি সংযোগ-কোড টেবিলের প্রতিটি সারি আসল system-এ চালিয়ে ঘর সবুজ বা লাল করে দেয়। পরে FitNesse নামে wiki-ভিত্তিক রূপটি পরিচিত হয়। আজকের রূপগুলো আরও চেনা: pytest-এর parametrize-এ টেবিলের প্রতিটি সারি একটি test, Gherkin-এর “Examples” টেবিলে প্রতিটি সারি একটি scenario, আর §৫-এর program-এ একটি dict থেকেই ৮টি test তৈরি হয়েছে। এভাবে টেবিল একসাথে requirement-এর নথি আর regression suite, আর নিয়ম বদলালে প্রথমে টেবিল বদলায়, তারপর কোড। Data-driven test নিয়ে পর্ব ৪৫ (Automation framework — data-driven, keyword-driven আর hybrid)-এ বিস্তারিত।

শর্ত খুব বেশি হলে প্রথম প্রশ্ন: শর্তগুলো কি সত্যিই একটি নিয়মে জড়িত? “Browser, ভাষা, payment method” এমন configuration-এর মান প্রায়ই কোনো নিয়মে একসাথে বাঁধা নয়; সেখানে combinatorial testing ভালো। NIST-এর গবেষকরা (D. Richard Kuhn ও সহকর্মীরা, ২০০০-এর দশকের শুরু থেকে) কয়েকটি ক্ষেত্রের software-এর ব্যর্থতা বিশ্লেষণ করে জানিয়েছেন যে বেশিরভাগ ব্যর্থতা এক বা দুটি factor-এর মিশ্রণে ঘটেছে, আর তাঁদের পাওয়া প্রায় সব ব্যর্থতা ছয় বা কম factor-এ; এটিই pairwise আর t-way testing-এর অভিজ্ঞতাভিত্তিক যুক্তি (পর্ব ১১)। তবে এটি নির্দিষ্ট data-র পর্যবেক্ষণ, সব software-এর জন্য প্রমাণ নয়।

শর্তগুলো নিয়মে জড়িত হলে টেবিল ভাঙুন: মধ্যবর্তী ফল (ছাড় কত, ক্রেতা কোন শ্রেণির) আলাদা টেবিলে হিসাব করে পরের টেবিলের একটি শর্ত বানান। এতে প্রতিটি টেবিল ছোট থাকে, আর পূর্ণ টেবিল চালানো সম্ভব হয়।

মূল উপলব্ধি: ভালো decision table একই সাথে মানুষের পড়ার নথি আর যন্ত্রের চালানোর test. শর্ত বেশি হলে আগে জিজ্ঞেস করুন, এগুলো নিয়ম না configuration; উত্তর ঠিক করে দেয় কোন কৌশল লাগবে।

অনুশীলন

কাগজ-কলমে করুন, তারপর উত্তর মিলিয়ে নিন। চাইলে উপরের program-গুলো বদলে নিজের উত্তর যাচাই করতে পারেন।

  1. Spec থেকে টেবিল আর test (test design): বাজারঘরের পণ্য ফেরতের একটি কাল্পনিক নিয়ম: “delivery-র ৭ দিনের মধ্যে ফেরত চাইলে, আর পণ্যের সিল না খোলা থাকলে পুরো টাকা ফেরত। সিল খোলা হলে, পণ্য ত্রুটিপূর্ণ হলে পুরো টাকা ফেরত, না হলে ফেরত নয়। ৭ দিন পার হলে কোনো ফেরত নয়।” শর্ত, পূর্ণ টেবিল, সবচেয়ে ছোট রূপ আর test case লিখুন।

    শর্ত: C1 ৭ দিনের মধ্যে, C2 সিল না খোলা, C3 পণ্য ত্রুটিপূর্ণ। কাজ: পুরো ফেরত / ফেরত নয়। পূর্ণ টেবিল ৮টি কলাম: YYY, YYN, YNY পুরো ফেরত; YNN আর N দিয়ে শুরু চারটি কলাম ফেরত নয়।

    ছোট রূপ: N-- → ফেরত নয় (৪টি কলাম ঢাকে), YY- → পুরো ফেরত, YNY → পুরো ফেরত, YNN → ফেরত নয়। মোট ৪টি rule; rule-count 4 + 2 + 1 + 1 = ৮. সমান ছোট আরেকটি রূপও বৈধ: N--, Y-Y, YYN, YNN. একটি script সব সম্ভাব্য মেশানো খুঁজে দেখেছে, সবচেয়ে কম ৪টি rule, আর ৪টির রূপ ঠিক এই দুটি।

    Test case (প্রথম রূপ থেকে, “−”-এ একটি মান বসিয়ে): দিন ৩, সিল অক্ষত, ত্রুটি নেই → পুরো ফেরত; দিন ৩, সিল খোলা, ত্রুটিপূর্ণ → পুরো ফেরত; দিন ৩, সিল খোলা, ত্রুটি নেই → ফেরত নয়; দিন ১০, যেকোনো → ফেরত নয়। আর ঝুঁকির কারণে দুটি বাড়তি: দিন ১০, সিল অক্ষত, ত্রুটিপূর্ণ (“−” কি সত্যিই প্রভাবহীন?), আর ঠিক দিন ৭ (সীমা; “৭ দিনের মধ্যে”-তে ৭ আছে কি না, PO-কে প্রশ্ন)।

  2. Failure পড়ুন (predict / read the output): Checkout-এর মোট বিলের একটি test-এর ইনপুট: অর্ডার ২০০০ টাকা, ঢাকার ভেতরে, সাধারণ ক্রেতা। Runner লিখল AssertionError: 1860 != 1800. কোনটি actual, কোনটি expected? Expected মানটি নিয়ম থেকে হিসাব করে দেখান। ভুলটি সম্ভবত কোথায়, আর ২৫০০ টাকার অর্ডারে একই test কী দেখাত?

    assertEqual(actual, expected) ক্রমে প্রথমটি actual (1860), দ্বিতীয়টি expected (1800). নিয়ম: ছাড় ২০০০-এর ১০% = ২০০; অর্ডার ২০০০ বা বেশি আর ঢাকার ভেতরে, তাই delivery ফ্রি; মোট ২০০০ − ২০০ + ০ = ১৮০০. কোড দিয়েছে ৬০ টাকা বেশি, অর্থাৎ ফ্রি delivery দেয়নি। সম্ভাব্য কারণ: ফ্রি delivery-র শর্তে ছাড়ের পরের অঙ্ক (১৮০০) ধরা হয়েছে। ২৫০০ টাকায় ছাড়ের পরেও ২২৫০ থাকে, তাই একই ভুল কোড ঠিক উত্তর দিত আর test পাস করত, যেমন §৭-এর “middle of band” চালানোয় দেখা গেছে।

  3. ভুলটি খুঁজুন (find the bug): একজন সহকর্মী delivery charge-এর ছোট টেবিল জমা দিয়েছেন: YY- → 0, YN- → 60, --Y → 60, N-N → 120. তাঁর যুক্তি: “সদস্য হলে সবসময় ৬০।” তাঁর test case-গুলো এই টেবিল থেকে বানানো, আর সব পাস করছে। টেবিলে কী ভুল, rule-count কী বলে, আর এই টেবিলের test কোন defect ধরতে পারবে না?

    Rule-count: 2 + 2 + 4 + 2 = ১০, যা ৮-এর বেশি, তাই কিছু কলাম দুটি rule-এ পড়েছে। খুলে দেখলে: YYY পড়ে YY- (0) আর --Y (60) দুটিতেই, অর্থাৎ টেবিল নিজেই বিরোধী উত্তর দেয়; নিয়ম অনুযায়ী ঠিক উত্তর 0. YNY-ও দুটিতে পড়ে, তবে দুটিরই উত্তর 60, তাই সেটি ক্ষতিহীন overlap. মূল ভুল তাঁর যুক্তিতে: “সদস্য হলে সবসময় ৬০” নিয়মে নেই; সদস্যের সুবিধা শুধু ঢাকার বাইরে। তাঁর টেবিল §৫-এর seeded defect-এর (সদস্যের যাচাই আগে) হুবহু প্রতিচ্ছবি, তাই সেই defect-ওয়ালা কোডে --Y থেকে বানানো test পাস করবে, আর YY- থেকে বানানো test-এ “−”-এ N বসালে সেটিও পাস করবে। একই ভুল ধারণা থেকে কোড আর test দুটোই লেখা হলে test কোডকে কখনো ধরতে পারে না।

  4. Coverage হিসাব: (ক) Delivery charge-এর ৮ কলামের পূর্ণ টেবিলে একটি suite-এর test-গুলো পড়ে এই কলামে: YYN, YNN, NNN, NYN, YYN. Coverage কত? (খ) Checkout-এর ১৬ কলামের extended-entry টেবিলে ১২টি আলাদা কলাম চলেছে। (গ) Coupon-এর দুই শর্তের টেবিলে (৪ কলাম, ১টি অসম্ভব) ৩টি test, তিনটি আলাদা সম্ভব কলামে। প্রতিটির coverage কত, আর (ক)-তে কোন কলাম বাদ পড়েছে?

    (ক) আলাদা কলাম ৪টি (YYN দুবার এসেছে, একবার গোনা হয়): ৪ ÷ ৮ = ৫০%. বাদ পড়েছে YYY, YNY, NYY, NNY, অর্থাৎ Plus সদস্যের প্রতিটি কলাম। Suite-টি সদস্যপদের শর্ত কখনো Y করেনি, তাই সদস্য-সংক্রান্ত কোনো defect ধরার সুযোগই নেই। (খ) ১২ ÷ ১৬ = ৭৫%. (গ) অসম্ভব কলাম হরে নেই, তাই ৩ ÷ ৩ = ১০০%; ভুল করে ৪ দিয়ে ভাগ করলে ৭৫% আসত। পরীক্ষায় প্রায়ই ঠিক এই ফাঁদটিই থাকে।

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

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

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

  1. Requirement থেকে শর্ত আর কাজ খুঁজে বের করা
  2. শর্তের মানের সংখ্যা গুণ করে মোট কলাম গোনা
  3. পালা করে Y/N বসিয়ে পূর্ণ টেবিল বানানো
  4. প্রতিটি কলামে requirement থেকে কাজ লেখা, ফাঁক আর বিরোধে প্রশ্ন তোলা
  5. Don't-care দিয়ে ছোট করা আর খুলে মিলিয়ে যাচাই
  6. প্রতিটি কলাম থেকে test case বানিয়ে চালানো

একটি নিয়মে ৪টি Y/N শর্ত আর একটি শর্তের ৩টি মান (যেমন payment: cash, mobile-wallet, card). পূর্ণ decision table-এ কয়টি কলাম?

  • 10
  • 32
  • 48
  • 19

তিনটি Y/N শর্তের একটি ছোট করা decision table-এ rule-গুলো Y−−, NY−, NNY, NNN. Rule-count যাচাইয়ে কী পাওয়া যায়?

  • ৪, তাই টেবিলে কলাম বাদ পড়েছে
  • ৮, গোনা মিলেছে, তবে উত্তর মেলাতে খুলে দেখা লাগবে
  • ১০, তাই কিছু কলাম দুবার এসেছে
  • ৮, তাই টেবিল নিশ্চিতভাবে সঠিক

একটি decision table-এ ৮টি কলাম, যার ২টি অসম্ভব (কোনো ইনপুটে ঘটতে পারে না)। Test suite চালিয়েছে ৫টি আলাদা সম্ভব কলাম। Decision table coverage কত?

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

Delivery charge-এর ছোট করা টেবিলে একটি rule “YY− → 0” (ঢাকার ভেতরে, অর্ডার ২০০০ বা বেশি, সদস্যপদ যা-ই হোক)। এই “−” সম্পর্কে কোন কথাটি সবচেয়ে সঠিক?

  • Requirement বলছে সদস্যপদের প্রভাব নেই; কোডেও নেই, তার নিশ্চয়তা নেই
  • কোডে সদস্যপদ এই ক্ষেত্রে কখনো পড়া হয় না, তা প্রমাণিত
  • সদস্যপদের মান অজানা, তাই এই rule-এর test করা যায় না
  • এই rule-এর জন্য test case লাগবে না

খসড়া requirement-এর দুটি বাক্য: “ঢাকার বাইরে Plus সদস্যের charge ৬০ টাকা” আর “Plus সদস্যের ২০০০ বা বেশি অর্ডারে delivery ফ্রি”। ঢাকার বাইরে ২৫০০ টাকার অর্ডার, ক্রেতা Plus সদস্য। Decision table-এর ভাষায় এটি কী?

  • ফাঁক (missing rule)
  • ক্ষতিহীন overlap
  • বিরোধ (contradiction)
  • অসম্ভব (infeasible) কলাম

“অর্ডার ১০০০-এর বেশি”, “অর্ডার ২০০০ বা বেশি” আর “অর্ডার ৩০০০ বা বেশি” তিনটি আলাদা Y/N শর্ত বানালে কী সমস্যা হয়, আর ভালো সমাধান কী?

  • কোনো সমস্যা নেই, ৮টি কলামের সবই test করা যায়
  • অনেক কলাম অসম্ভব হয়; extended entry-তে একটি চার-মানের “অর্ডারের দল” শর্ত নেওয়া ভালো
  • অসম্ভব কলামগুলোর জন্য আলাদা test লাগবে
  • তিনটির দুটি শর্ত বাদ দিতে হবে

শব্দকোষ

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

মনে রাখুন

  1. Decision table-এর প্রতিটি কলাম একটি শর্ত-মিশ্রণ আর তার প্রত্যাশিত কাজ; কলাম = মানের সংখ্যার গুণফল (Y/N হলে 2n).
  2. ছোট করার নিয়ম: কাজ এক, ঠিক একটি শর্তে পার্থক্য; তারপর rule-count আর খুলে মেলানো দুটোই।
  3. “−” requirement-এর দাবি, কোডের নয়; টাকার নিয়মে শর্ত কম হলে পূর্ণ টেবিল চালান।
  4. টেবিল ভরাতে গিয়ে ফাঁক, বিরোধ আর overlap খুঁজুন, আর উত্তর আন্দাজ না করে PO-কে প্রশ্ন করুন।
  5. অসম্ভব কলাম coverage-এর হরে নেই; নির্ভরশীল সংখ্যার শর্তকে extended entry-র দলে বদলান, আর প্রতিনিধি মান নিন সীমায়।

পরের পর্বে: এখানে ফল নির্ভর করেছে এখনকার শর্তের ওপর। কিন্তু বাজারঘরের অর্ডার বাতিল করা যাবে কি না, তা নির্ভর করে অর্ডারটি আগে কোন অবস্থায় ছিল তার ওপর। পর্ব ১০-এ state transition testing: অবস্থা, ঘটনা আর অবৈধ পথ।

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

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