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

Testing-এর সাতটি নীতি আর tester-এর মনস্তত্ত্ব

The Seven Testing Principles and the Psychology of Testing

Taught in Bangla, this lesson explains the seven testing principles listed in the ISTQB syllabus: testing shows presence of defects, exhaustive testing is impossible, early testing, defect clustering, tests wear out, context dependence and the absence-of-defects fallacy. In-page Python computes a Pareto table from a defect list and shows an old suite missing a new bug. It weighs the evidence behind the 1:10:100 cost claim, covers confirmation bias and levels of independence, and rewrites a blaming bug comment.

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

  • সাতটি নীতি নিজের ভাষায় বলা, আর প্রতিটির একটি বাজারঘর-উদাহরণ দেওয়া
  • একটি defect তালিকা থেকে Pareto হিসাব করে কোথায় বেশি test দরকার বের করা
  • পুরোনো test suite কেন নতুন bug ধরতে পারে না, নিজে চালিয়ে দেখা
  • “১:১০:১০০” খরচের দাবিটির প্রমাণ কতটা শক্ত, সেটি বিচার করা
  • Confirmation bias আর independence বোঝা, আর একটি দোষারোপের bug মন্তব্যকে নিরপেক্ষ রূপে লেখা

১ · নীতি কেন দরকার — অভিজ্ঞতার সাতটি সারকথা

পর্ব ০২ (Testing কী — error, defect, failure আর verification বনাম validation)-এ দেখেছেন testing কী, আর একটি defect কীভাবে failure হয়ে ব্যবহারকারীর সামনে আসে। এবার প্রশ্ন: test করার সময় কোন সাধারণ সত্যগুলো মাথায় রাখবেন? কোথায় বেশি সময় দেবেন, কখন থামবেন, আর “সব test পাস” শুনে কতটা নিশ্চিন্ত হবেন?

একজন অভিজ্ঞ রাঁধুনির কথা ভাবুন। তিনি কোনো বই মুখস্থ করে রান্না করেন না, কিন্তু কিছু সাধারণ নিয়ম জানেন: “লবণ শুরুতে কম দিন, পরে বাড়ানো যায়, কমানো যায় না।” “যে চুলায় আগে তরকারি পুড়েছে, সেখানে বেশি নজর রাখুন।” “একই মেহমানের জন্য রান্না আর বিয়ের দাওয়াতের রান্না এক নয়।” Testing-এর সাতটি নীতি ঠিক এমন: বহু দলের বহু বছরের ভুল থেকে শেখা সংক্ষিপ্ত সারকথা।

এই সাতটি নীতি সবচেয়ে বেশি পরিচিত ISTQB (International Software Testing Qualifications Board, ২০০২ সালে প্রতিষ্ঠিত)-এর Foundation Level syllabus থেকে। আমাদের জানামতে সর্বশেষ সংস্করণ CTFL v4.0 (২০২৩; সংশোধিত v4.0.1, ২০২৪)। নিচে তার ক্রম আর নাম, আমাদের ভাষায়; আগের (২০১৮) সংস্করণের নাম বন্ধনীতে:

  1. Testing defect-এর উপস্থিতি দেখায়, অনুপস্থিতি নয়।
  2. সব কিছু test করা অসম্ভব (exhaustive testing is impossible).
  3. আগে testing সময় আর টাকা বাঁচায় (early testing).
  4. Defect জোট বাঁধে (defect clustering).
  5. Test-এর ধার কমে যায় (tests wear out; আগে pesticide paradox).
  6. Testing প্রসঙ্গের ওপর নির্ভর করে (context dependent).
  7. “Defect নেই” মানেই সফল নয় (absence-of-defects fallacy; আগে absence-of-errors fallacy).

সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৪৫-এ তালিকাটি এক অনুচ্ছেদে দেখেছেন (পড়ে না থাকলে সমস্যা নেই)। এখানে প্রতিটি নীতি হাতে-কলমে দেখব: একটি Pareto হিসাব, একটি পুরোনো test suite-এর অন্ধ জায়গা, আর একটি bias-এর পরীক্ষা, সবই বাজারঘর অনলাইন দোকানের পরিচিত নিয়ম দিয়ে:

বাজারঘরের নিয়ম (পুরো মডিউলে একই)

Coupon: ১০০০ টাকার বেশি অর্ডারে ১০% ছাড়, সর্বোচ্চ ৩০০ টাকা; ছাড় পূর্ণ টাকায়, ভগ্নাংশ বাদ। Delivery charge: ঢাকার ভেতরে ৬০ টাকা (অর্ডার ২০০০ টাকা বা বেশি হলে ফ্রি), বাইরে ১২০ টাকা। এ ছাড়া phone number ঘর আর order status.

সাতটি নীতি, তিনটি প্রশ্নে ভাগ করা

ISTQB-এর ক্রম-নম্বর রাখা হয়েছে; ভাগগুলো মনে রাখার সুবিধার জন্য আমাদের করা

Seven testing principles grouped into three questions Testing কী পারে না? কখন আর কোথায় জোর দেবেন? Testing ধারালো রাখবেন কীভাবে? ১ · উপস্থিতি দেখায়, অনুপস্থিতি নয় ২ · সব input test করা অসম্ভব ৭ · সব পাস ≠ সফল product ৩ · যত আগে test, তত কম ক্ষতি ৪ · Defect অল্প জায়গায় জমে ৫ · একই test-এর ধার কমে ৬ · প্রসঙ্গ বুঝে test-এর ধরন
ছবি ৩.১ — প্রথম ভাগ testing-এর সীমা, দ্বিতীয় ভাগ পরিশ্রম কোথায় খরচ করবেন, তৃতীয় ভাগ testing-কে কাজের রাখার উপায়।

২ · নীতি ১, ২ আর ৭ — testing-এর সীমা

নীতি ১: উপস্থিতি দেখায়, অনুপস্থিতি নয়

বাজার থেকে এক কেজি আম কিনলেন। দোকানি পাঁচটি আম কেটে দেখালেন, সব মিষ্টি। এতে জানলেন ওই পাঁচটি মিষ্টি; বাকি আমের একটিও টক নয়, এমন প্রমাণ পেলেন না। Test ঠিক এমন: একটি test fail করলে নিশ্চিত হন যে defect আছে। সব test পাস করলে শুধু জানেন, এই input-গুলোতে ভুল পাওয়া যায়নি। ISTQB-এর ভাষায়, testing অজানা defect থেকে যাওয়ার সম্ভাবনা কমায়, কিন্তু সঠিকতা প্রমাণ করে না। কথাটি সাধারণত Edsger Dijkstra-র নামে চলে; ১৯৬৯ সালের NATO software engineering সম্মেলনের রিপোর্টে (১৯৭০ সালে প্রকাশিত) এর একটি রূপ আছে।

নীতি ২: সব input test করা অসম্ভব

বাজারঘরের checkout-এ মাত্র তিনটি ঘর ধরুন: অর্ডারের মোট টাকা, জেলা আর phone number. Phone number যদি ১১ অঙ্কের হয়, শুধু অঙ্কের সম্ভাব্য সারিই ১০১১টি, মানে দশ হাজার কোটি। তার সাথে টাকা আর জেলার মিশ্রণ যোগ করলে সংখ্যাটি আরও বহু গুণ। পর্ব ০২-এ এমন একটি হিসাব নিজে চালিয়েছেন। তাই প্রশ্ন “সব test করব কি না” নয়; প্রশ্ন হলো কোন অল্প কয়টি test সবচেয়ে বেশি ঝুঁকি ঢাকে। এর উত্তর দেয় test design technique (মডিউল ২, যেমন পর্ব ৭-এ equivalence partitioning আর পর্ব ৮-এ boundary value analysis) আর risk-based testing (পর্ব ৭৩)।

নীতি ৭: “Defect নেই” মানেই সফল নয়

ধরুন বাজারঘরের দল spec-এর প্রতিটি লাইন test করল, সব defect ঠিক করল। কিন্তু spec অনুযায়ী delivery charge দেখানো হয় একেবারে শেষ ধাপে, টাকা দেওয়ার ঠিক আগে। ক্রেতারা শেষ মুহূর্তে ১২০ টাকা বাড়তি দেখে বিরক্ত হয়ে cart ছেড়ে চলে যাচ্ছেন। Software spec মানছে, কোনো test লাল নয়, তবু product ব্যর্থ। এটি spec-এর সাথে মেলানো (verification) আর আসল প্রয়োজনের সাথে মেলানো (validation)-এর পার্থক্য, যা পর্ব ০২-এর বিষয়। ISTQB-এর syllabus এখানে Barry Boehm-এর ১৯৮১ সালের বই উদ্ধৃত করে বলে: verification-এর পাশাপাশি validation-ও করতে হবে।

“১০০% test পাস” একটি রিপোর্ট, নিশ্চয়তা নয়। পরের প্রশ্নগুলো জিজ্ঞেস করুন: কোন input-গুলো test হয়েছে, কোনগুলো হয়নি? Test-গুলো কি requirement থেকে লেখা, নাকি কোড দেখে? ব্যবহারকারীর আসল প্রয়োজন কেউ যাচাই করেছে কি?

৩ · নীতি ৩ — early testing, আর “১:১০:১০০”-এর সত্যতা

Early testing মানে কোড লেখা শেষ হওয়ার অপেক্ষা না করে শুরুতেই testing-এর কাজ শুরু করা। শুরুর testing মানে প্রায়ই কোনো কিছু না চালিয়ে পড়ে দেখা: requirement-এর review, নকশার review. একে বলে static testing (পর্ব ০৬-এ বিস্তারিত)। ISTQB-এর যুক্তিটি সরল: শুরুর একটি ভুল পরের সব কাজে ঢুকে পড়ে। Requirement ভুল হলে নকশা ভুল, কোড ভুল, test case-ও ভুল প্রত্যাশা নিয়ে লেখা হয়।

বাজারঘরের coupon নিয়মটি আবার পড়ুন: “১০০০ টাকার বেশি অর্ডারে”। ঠিক ১০০০ টাকার অর্ডারে ছাড় পাবে কি? লেখা অনুযায়ী পাবে না, কিন্তু একজন developer সহজেই >= লিখে ফেলতে পারেন। একই অস্পষ্টতা কোন ধাপে ধরা পড়লে কতটা কাজ ফিরে করতে হয়, দেখুন:

কোথায় ধরা পড়লকী কী আবার করতে হয়
Requirement reviewProduct owner-কে একটি প্রশ্ন, spec-এ একটি শব্দ বদল
Code review / unit testকোডের এক লাইন, একটি test; spec-ও পরিষ্কার করা
System testBug report, fix, নতুন build, আবার test আর regression
Production-এওপরের সব, সাথে ভুল ছাড় পাওয়া অর্ডারের হিসাব, ক্রেতার অভিযোগ, হিসাব বিভাগের সমন্বয়, সুনামের ক্ষতি

টেবিলের সারকথা স্পষ্ট: যত দেরিতে ধরা পড়ে, তত বেশি ধাপ জড়িয়ে পড়ে। কিন্তু এখান থেকে প্রায়ই একটি নির্দিষ্ট সংখ্যা বলা হয়: “requirement-এ ধরলে খরচ ১, test-এ ১০, production-এ ১০০।” এই cost-of-change-এর “১:১০:১০০” কতটা সত্য?

দেরিতে ধরা defect-এর খরচ বেশি, এই ধারণার সবচেয়ে পরিচিত উৎস Barry Boehm-এর Software Engineering Economics (১৯৮১)। Boehm আর Victor Basili ২০০১ সালে IEEE Computer-এ “Software Defect Reduction Top 10 List”-এ লেখেন, delivery-র পরে একটি সমস্যা খুঁজে ঠিক করা প্রায়ই requirement বা নকশার সময়ের চেয়ে প্রায় ১০০ গুণ ব্যয়বহুল। কিন্তু একই লেখায় তাঁরা যোগ করেন: ছোট, কম গুরুত্বপূর্ণ system-এ অনুপাতটি বরং ৫:১-এর কাছাকাছি। পরে Laurent Bossavit-এর বই The Leprechauns of Software Engineering দেখায়, অনেক বই যে নির্দিষ্ট গুণক আর লেখচিত্র উদ্ধৃত করে, সেগুলোর মূল data খুঁজে পাওয়া কঠিন। আর Tim Menzies ও সহকর্মীরা ২০১৭ সালে (Empirical Software Engineering) ১৭১টি project-এর data বিশ্লেষণ করে এমন কোনো “দেরির প্রভাব”-এর প্রমাণ পাননি। সেই project-গুলো সব একই পদ্ধতিতে (Team Software Process) চালানো ছিল, তাই ফলটিও সব জায়গায় খাটবে এমন নয়।

সৎ উপসংহার

“১:১০:১০০” একটি বহুল উদ্ধৃত মোটা দাগের ধারণা, মাপা সর্বজনীন পরিসংখ্যান নয়। প্রমাণ মিশ্র: বড়, safety-critical system-এ দেরির খরচ সত্যিই বিশাল হতে পারে; ছোট web app-এ, যেখানে দিনে কয়েকবার deploy হয়, অনুপাত অনেক কম। তবু early testing-এর মূল যুক্তি টেকে: শুরুর ভুল পরের কাজে ছড়িয়ে পড়ে, আর production-এর ক্ষতি (ভুল টাকা, ক্রেতার আস্থা) শুধু developer-এর সময় দিয়ে মাপা যায় না। ইন্টারভিউতে “১:১০:১০০” বললে এই সতর্কতাটুকুও যোগ করুন।

৪ · নীতি ৪ — defect জোট বাঁধে: Pareto হিসাব হাতে-কলমে

মহল্লার রাস্তায় খানাখন্দ সব জায়গায় সমান থাকে না; যে মোড়ে ভারী ট্রাক ঘোরে আর পানি জমে, সেখানেই বারবার গর্ত হয়। Software-এও তাই। ISTQB-এর ভাষায়, অল্প কয়েকটি component-এ সাধারণত বেশিরভাগ defect পাওয়া যায়, বা সেগুলোই বেশিরভাগ failure ঘটায়। একে Pareto principle-এর একটি উদাহরণ বলা হয়। কেন এমন হয়? জটিল ব্যবসায়িক নিয়ম, বারবার বদলানো কোড, অনেক বাইরের নির্ভরতা, আর তাড়াহুড়োয় লেখা অংশ সাধারণত একই জায়গায় মেলে।

নিচের তালিকা বানানো data, কোনো আসল project-এর নয়: বাজারঘরের একটি release-এ ১০টি module-এ পাওয়া defect, আর প্রতিটি module-এর কোডের লাইন। প্রথমে stepper-এ হাতে হিসাবটি দেখুন, তারপর একই হিসাব code-এ চালান।

1checkout      342coupon        223delivery      174cart          135search        106login          87order-status   68admin-stock    59product-page   310profile        2
চলমান হিসাব
module
যোগফল
cum %
  1. সাজানো আর মোট। প্রতিটি module-এর defect গুনে বেশি থেকে কম ক্রমে সাজানো হলো। মোট defect ১২০টি। এবার ওপর থেকে একটি একটি করে যোগ করব।
  2. প্রথম সারি। checkout-এ ৩৪টি। ৩৪ ÷ ১২০ = ২৮.৩%. দশটির একটি module-এই এক-চতুর্থাংশের বেশি defect.
  3. দুটি module, মানে ২০%. ৩৪ + ২২ = ৫৬, অর্থাৎ ৪৬.৭%. সমানভাবে ছড়ালে ২০% module-এ থাকত ২০% defect; এখানে তার দ্বিগুণের বেশি। জমাট বাঁধা স্পষ্ট, কিন্তু “৮০/২০” নয়।
  4. তিনটি module. ৫৬ + ১৭ = ৭৩, অর্থাৎ ৬০.৮%. checkout, coupon আর delivery: তিনটিই টাকার হিসাবের অংশ।
  5. ৮০% রেখা। cart (১৩) আর search (১০) যোগ করে ৯৬, ঠিক ৮০.০%. এই data-য় ৮০% defect আছে ৫০% module-এ। আসল অনুপাত project-ভেদে আলাদা হয়।
  6. বাকি অর্ধেক। শেষ ৫টি module মিলে ২৪টি, ২০%. কম, কিন্তু শূন্য নয়। সিদ্ধান্ত: প্রথম ৩টি module-এ বেশি test আর review, বাকিগুলোতে হালকা কিন্তু নিয়মিত test.

এবার একই হিসাব Python-এ। শুধু defect-এর সংখ্যা নয়, প্রতি ১০০০ লাইনে কয়টি defect, অর্থাৎ defect density-ও বের করব। “চালান” চাপুন; প্রথমবার ব্রাউজারে Python (Pyodide) নামতে কয়েক সেকেন্ড লাগে।

# Invented data (not from a real project): defects found in
# one release of the Bazarghar shop, per module, with module size.
defects = {            # module: (defects, lines of code)
    "checkout": (34, 2400), "coupon": (22, 600),
    "delivery": (17, 500), "cart": (13, 1500),
    "search": (10, 2200), "login": (8, 900),
    "order-status": (6, 700), "admin-stock": (5, 1100),
    "product-page": (3, 1800), "profile": (2, 800),
}
total = sum(d for d, _ in defects.values())
ranked = sorted(defects, key=lambda m: -defects[m][0])

print(f"{'module':<13}{'bugs':>4}{'cum%':>7}")
running = 0
for m in ranked:
    before = running / total
    running += defects[m][0]
    mark = " <- 80%" if before < 0.8 <= running / total else ""
    print(f"{m:<13}{defects[m][0]:>4}{running / total:>7.1%}{mark}")

top2 = sum(defects[m][0] for m in ranked[:2])
print(f"\ntotal {total}; top 2 of 10 modules = {top2 / total:.1%}")

print("\ndefects per 1000 lines (density):")
dens = {m: d / loc * 1000 for m, (d, loc) in defects.items()}
for m in sorted(dens, key=dens.get, reverse=True)[:3]:
    print(f"  {m:<11}{dens[m]:5.1f}")

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

module       bugs   cum%
checkout       34  28.3%
coupon         22  46.7%
delivery       17  60.8%
cart           13  71.7%
search         10  80.0% <- 80%
login           8  86.7%
order-status    6  91.7%
admin-stock     5  95.8%
product-page    3  98.3%
profile         2 100.0%

total 120; top 2 of 10 modules = 46.7%

defects per 1000 lines (density):
  coupon      36.7
  delivery    34.0
  checkout    14.2

প্রথম অংশ stepper-এর হিসাবই মেলায়: running চলমান যোগফল, আর before < 0.8 <= running / total শর্তটি ঠিক সেই সারিতে চিহ্ন বসায় যেখানে যোগফল প্রথমবার ৮০% ছোঁয়। শেষ অংশে নতুন একটি শিক্ষা: সংখ্যায় checkout প্রথম, কিন্তু checkout সবচেয়ে বড় module (২৪০০ লাইন)। ঘনত্বে এগিয়ে coupon (প্রতি ১০০০ লাইনে ৩৬.৭) আর delivery (৩৪.০), দুটিই ছোট কিন্তু নিয়মে ভরা। বড় module-এ বেশি defect থাকা স্বাভাবিক; ঘনত্ব দেখায় কোন কোড আসলেই ভঙ্গুর। দুটি মাপ একসাথে দেখে সিদ্ধান্ত নিন।

সাবধান: defect clustering-এর data নিজেই পক্ষপাতদুষ্ট হতে পারে। যেখানে বেশি test হয়েছে, সেখানে বেশি defect পাওয়া যায়। যে module কেউ test করেনি, তার তালিকায় শূন্য থাকলেও সেখানে bug নেই এমন নয়। তাই clustering-কে risk-এর একটি ইঙ্গিত হিসেবে নিন, চূড়ান্ত রায় হিসেবে নয় (পর্ব ৭৩-এ risk-based testing).

৫ · নীতি ৫ — test-এর ধার কমে যায়

কৃষক একই কীটনাশক বছরের পর বছর দিলে টিকে থাকা পোকারা একসময় আর মরে না। Boris Beizer তাঁর Software Testing Techniques (দ্বিতীয় সংস্করণ, ১৯৯০) বইয়ে এই তুলনা থেকেই “pesticide paradox” নামটি দেন। ISTQB-এর নতুন syllabus সরল নাম ব্যবহার করে: tests wear out. একটি test suite যে bug-গুলো ধরার জন্য লেখা, সেগুলো ঠিক হয়ে যাওয়ার পর suite প্রতিদিন সবুজ দেখায়। এই সবুজ রং আরামদায়ক, কিন্তু নতুন কোনো তথ্য দেয় না।

Test পুরোনো হয় মূলত দুই কারণে। এক, কোড বদলায় কিন্তু test বদলায় না: নতুন শাখা, নতুন input-এর ধরন test-এর নাগালের বাইরে থাকে। দুই, একই data বারবার: সবসময় “Dhaka” আর “Rajshahi” দিয়ে test করলে বাকি ৬২টি জেলা বা বাংলায় লেখা নাম কখনো যাচাই হয় না। নিচের stepper-এ একটি বাস্তবসম্মত ঘটনা দেখুন।

  1. v1Dhaka → 60পুরোনো কোড
  2. v2+ "ঢাকা "বাংলা নাম যোগ
  3. v3+ "ঢাকা"ঠিক করা কোড
OldSuite → v1২টি test
test_dhaka    "Dhaka"    → 60  ✓
test_outside  "Rajshahi" → 120 ✓
OK
প্রতিদিনের CIএকই ২টি test
সোমবার    OK
মঙ্গলবার   OK
বুধবার     OK
… সব দিন সবুজ, নতুন তথ্য নেই
v2নতুন বদল
if district in ("Dhaka",
                "ঢাকা "):
    return 60
return 120
# "ঢাকা"-র শেষে একটি বাড়তি space
OldSuite → v2একই ২টি test
test_dhaka    "Dhaka"    → 60  ✓
test_outside  "Rajshahi" → 120 ✓
OK  ← অথচ bug আছে
NewTests → v2নতুন test
test_dhaka_in_bangla
  "ঢাকা" → 120, চাই 60
FAIL: 120 != 60
সব test → v3৩টি test
test_dhaka            ✓
test_outside          ✓
test_dhaka_in_bangla  ✓
OK — পুরোনো ২টি এখন regression
  1. শুরু। v1 শুধু ইংরেজি “Dhaka” চেনে। দুটি test লেখা হয়েছিল: ঢাকা হলে ৬০, বাইরে ১২০. দুটিই পাস। এখানে কোনো সমস্যা নেই।
  2. প্রতিদিন সবুজ। CI প্রতিদিন এই দুটি test চালায়, প্রতিদিন OK. প্রথম দিনের পর থেকে এই সবুজ ফল আর নতুন কিছু জানায় না; কীটনাশক কাজ করছে বলে মনে হচ্ছে, কারণ পুরোনো পোকা আর নেই।
  3. কোড বদলাল। বাংলায় জেলার নাম লেখার সুবিধা যোগ হলো। কিন্তু developer “ঢাকা”-র শেষে ভুল করে একটি space রেখে দিয়েছেন। এখন বাংলায় “ঢাকা” লিখলে মিল হয় না, আর ক্রেতার কাছ থেকে ১২০ টাকা নেওয়া হয়।
  4. পুরোনো suite অন্ধ। একই দুটি test v2-তে চালানো হলো: আবার OK. কারণ test-গুলো শুধু “Dhaka” আর “Rajshahi” পাঠায়; নতুন শাখাটি তারা কখনো ছোঁয় না। সবুজ রং মিথ্যা নয়, শুধু অসম্পূর্ণ।
  5. নতুন test, নতুন তথ্য। বদলের জন্য একটি নতুন test লেখা হলো: “ঢাকা” পাঠালে ৬০ আসা উচিত। ফল এলো ১২০, test FAIL. নতুন কোডের সাথে নতুন test-ই bug ধরল।
  6. ঠিক করা আর রেখে দেওয়া। v3-তে space মুছে ফেলা হলো; তিনটি test-ই পাস। পুরোনো দুটি test ফেলে দেওয়া হয়নি: সেগুলো এখন regression test, যাতে পুরোনো আচরণ ভেঙে না যায়। ধার কমে নতুন bug খোঁজার কাজে, পাহারার কাজে নয়।

এবার ঘটনাটি আসল unittest দিয়ে চালান। একই দুটি test v1 আর v2-তে, তারপর নতুন test v2-তে:

import sys, unittest

def charge_v1(district):          # rule: Dhaka 60, outside 120
    return 60 if district == "Dhaka" else 120

def charge_v2(district):          # v2 adds Bangla names (a typo!)
    if district in ("Dhaka", "ঢাকা "):
        return 60
    return 120

class OldSuite(unittest.TestCase):          # written for v1
    charge = staticmethod(charge_v1)
    def test_dhaka(self):
        self.assertEqual(self.charge("Dhaka"), 60)
    def test_outside(self):
        self.assertEqual(self.charge("Rajshahi"), 120)

class OldSuiteOnV2(OldSuite):               # same tests, new code
    charge = staticmethod(charge_v2)

class NewTests(unittest.TestCase):          # tests for the change
    def test_dhaka_in_bangla(self):
        self.assertEqual(charge_v2("ঢাকা"), 60)

run = unittest.TextTestRunner(stream=sys.stdout, verbosity=1)
load = unittest.TestLoader().loadTestsFromTestCase
for case in (OldSuite, OldSuiteOnV2, NewTests):
    print(f"--- {case.__name__}")
    run.run(load(case))

আসল আউটপুট (ব্রাউজারের Python, মাঝের দাগ-রেখা ছাঁটা):

--- OldSuite
..
Ran 2 tests in 0.000s

OK
--- OldSuiteOnV2
..
Ran 2 tests in 0.000s

OK
--- NewTests
F
FAIL: test_dhaka_in_bangla (__main__.NewTests.test_dhaka_in_bangla)
…
AssertionError: 120 != 60

Ran 1 test in 0.001s

FAILED (failures=1)

প্রতিটি বিন্দু (.) একটি পাস করা test, F একটি fail. OldSuiteOnV2 class-টি OldSuite-এর test-গুলো উত্তরাধিকারে পায়, শুধু charge বদলে v2 বসায়; তাই হুবহু একই test নতুন কোডে চলে, আর তবুও OK. নতুন test-এর বার্তা 120 != 60: প্রথম মান কোডের আসল ফল, দ্বিতীয়টি প্রত্যাশিত। stream=sys.stdout দেওয়া হয়েছে যাতে ফল পাতায় দেখা যায়, আর unittest.main() সরাসরি ডাকা হয়নি, কারণ সেটি শেষে sys.exit ডেকে block থামিয়ে দেয়।

প্রতিকার কী? ISTQB-এর পরামর্শ: বিদ্যমান test আর test data বদলানো, নতুন test লেখা। বাস্তবে এর মানে: কোড বদলালে সেই বদলের জন্য নতুন test; test data-য় বৈচিত্র্য (বাংলা নাম, বড়-ছোট হাতের অক্ষর, ফাঁকা স্থান); নতুন কৌশল (পর্ব ১৪-এর অভিজ্ঞতাভিত্তিক আর পর্ব ২০-এর exploratory testing); আর test-এর নিজের মান মাপা (পর্ব ৫৯-এর mutation testing). কিন্তু পুরোনো test মুছবেন না; regression ধরতে সেগুলোর বারবার চলাটাই কাজের।

৬ · নীতি ৬ — testing প্রসঙ্গের ওপর নির্ভর করে

একই রাঁধুনি বাড়ির ভাত আর হাসপাতালের রোগীর পথ্য একইভাবে রাঁধেন না। Testing-ও তেমন: সব জায়গায় খাটে এমন একটি “সেরা” পদ্ধতি নেই। ISTQB এখানে Cem Kaner-এর context-driven testing-এর কাজ উদ্ধৃত করে। কোন প্রশ্নগুলো প্রসঙ্গ ঠিক করে: ভুল হলে ক্ষতি কতটা? কত ঘন ঘন release? কোনো আইন বা মান মানতে হয় কি? দলে কারা আছেন, সময় কতটা?

প্রসঙ্গভুলের ক্ষতিtesting-এর ধরন
বাজারঘর (অনলাইন দোকান)টাকার হিসাব ভুল, ক্রেতা হারানোটাকার নিয়মে গভীর test, দ্রুত release-এ automated regression, কিছু exploratory
হাসপাতালের ওষুধের মাত্রা হিসাবের softwareরোগীর জীবনলিখিত প্রমাণসহ test, উচ্চ independence, মান মেনে চলা, প্রতিটি requirement-এর traceability
একটি ছোট মোবাইল গেমখেলোয়াড়ের বিরক্তিখেলার অনুভূতি আর বিভিন্ন ফোনে চলা নিয়ে বেশি; আনুষ্ঠানিক দলিল কম

এই নীতির ব্যবহারিক মানে: অন্য কোম্পানির “best practice” বা এই কোর্সেরই কোনো কৌশল অন্ধভাবে কপি করবেন না। প্রথমে জিজ্ঞেস করুন, আমার প্রসঙ্গে ঝুঁকি কোথায়। পর্ব ১৭-এর test strategy ঠিক এই প্রশ্নের লিখিত উত্তর।

৭ · Tester-এর মনস্তত্ত্ব — confirmation bias আর independence

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

Testing-এ এর চেহারা চেনা। যিনি কোড লিখেছেন, তিনি সাধারণত দেখাতে চান “কাজ করছে”, তাই এমন input বাছেন যা কাজ করবে বলে জানেন: স্বাভাবিক পথ, বা happy path. Tester-এর লক্ষ্য উল্টো: ভাঙার চেষ্টা। সীমার মান, ভুল input, অদ্ভুত ক্রম, অর্থাৎ negative test. Glenford Myers-এর The Art of Software Testing (১৯৭৯) testing-কে সংজ্ঞা দিয়েছিল ঠিক এভাবে: ভুল খুঁজে পাওয়ার উদ্দেশ্যে প্রোগ্রাম চালানো। নিচের code একই coupon ফাংশনে দুই মানসিকতার test পাশাপাশি চালায়। ফাংশনে requirement থেকে একটি সূক্ষ্ম বিচ্যুতি আছে; আগে নিজে খুঁজে দেখুন।

import sys, unittest

def coupon_discount(total):
    """Rule: orders above 1000 taka get 10% off, at most 300."""
    if total >= 1000:                 # the author's code
        return min(total // 10, 300)
    return 0

class AuthorTests(unittest.TestCase):     # "show that it works"
    def test_1500(self):
        self.assertEqual(coupon_discount(1500), 150)
    def test_5000_capped(self):
        self.assertEqual(coupon_discount(5000), 300)
    def test_500(self):
        self.assertEqual(coupon_discount(500), 0)

class TesterTests(unittest.TestCase):     # "try to break it"
    def test_exactly_1000(self):
        self.assertEqual(coupon_discount(1000), 0)
    def test_1010(self):
        self.assertEqual(coupon_discount(1010), 101)
    def test_cap_edge_3000(self):
        self.assertEqual(coupon_discount(3000), 300)

run = unittest.TextTestRunner(stream=sys.stdout, verbosity=2)
load = unittest.TestLoader().loadTestsFromTestCase
for case in (AuthorTests, TesterTests):
    print(f"=== {case.__name__}")
    run.run(load(case))

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

=== AuthorTests
test_1500 (__main__.AuthorTests.test_1500) ... ok
test_500 (__main__.AuthorTests.test_500) ... ok
test_5000_capped (__main__.AuthorTests.test_5000_capped) ... ok

Ran 3 tests in 0.000s

OK
=== TesterTests
test_1010 (__main__.TesterTests.test_1010) ... ok
test_cap_edge_3000 (__main__.TesterTests.test_cap_edge_3000) ... ok
test_exactly_1000 (__main__.TesterTests.test_exactly_1000) ... FAIL

FAIL: test_exactly_1000 (__main__.TesterTests.test_exactly_1000)
…
AssertionError: 100 != 0

Ran 3 tests in 0.000s

FAILED (failures=1)

লেখকের তিনটি test-ই পাস: ১৫০০, ৫০০০ আর ৫০০ টাকা, তিনটিই সীমা থেকে দূরে। Tester সরাসরি সীমায় গেছেন: ঠিক ১০০০ টাকায় নিয়ম বলে ছাড় ০, কোড দিল ১০০, কারণ লেখা আছে >=, হওয়া উচিত >. এটিই §৩-এর সেই অস্পষ্টতা, এবার কোডে। লক্ষ করুন, লেখক অসৎ নন; তাঁর test-গুলো সঠিক। সমস্যা হলো কোন প্রশ্ন জিজ্ঞেস করা হয়েছে। (unittest test-গুলো নামের বর্ণানুক্রমে চালায়, তাই ক্রম লেখার ক্রম থেকে আলাদা। // পূর্ণসংখ্যার ভাগ, তাই ১০১০-এ ছাড় ১০১ টাকা।)

Independence-এর চারটি স্তর

Bias কমানোর একটি উপায় হলো অন্য কারও চোখ। ISTQB-এর syllabus (v4.0.1) independence of testing-এর চারটি স্তর বলে। বাজারঘরের উদাহরণে:

স্তরকে test করেনবাজারঘরে
No independenceলেখক নিজেcoupon কোডের লেখক তাঁর unit test লেখেন
Some independenceএকই দলের সহকর্মীপাশের developer code review করেন
High independenceপ্রতিষ্ঠানের ভেতরে, কিন্তু দলের বাইরের testerআলাদা QA দল system test করে
Very high independenceপ্রতিষ্ঠানের বাইরের testerবাইরের একটি দল নিরাপত্তা যাচাই করে

বেশি independence সবসময় ভালো নয়। Syllabus নিজেই অসুবিধাগুলো বলে: দূরের tester দল থেকে বিচ্ছিন্ন হয়ে পড়তে পারেন, যোগাযোগ কমে, সম্পর্ক প্রতিপক্ষের মতো হয়ে যায়, developer-রা মানের দায় tester-এর ঘাড়ে চাপান, আর tester-কে release দেরির “বাধা” মনে হয়। তাই সাধারণ পরামর্শ: একাধিক স্তর একসাথে। Developer নিজে unit test করেন (নিজের কোড তিনিই সবচেয়ে ভালো চেনেন), দলের tester system test করেন, ব্যবসার প্রতিনিধি acceptance test করেন। পর্ব ৭৬-এ agile দলের whole-team quality দেখবেন।

৮ · দোষারোপ ছাড়া bug-এর খবর দেওয়া

ISTQB-এর syllabus একটি তিক্ত সত্য সরাসরি বলে: tester প্রায়ই খারাপ খবরের বাহক, আর খারাপ খবরের বাহককে দোষ দেওয়া মানুষের সাধারণ স্বভাব। Developer-এর কাছে bug report নিজের কাজের সমালোচনা মনে হতে পারে। তাই tester-এর কাছে যোগাযোগ দক্ষতা প্রায় test design-এর মতোই গুরুত্বপূর্ণ। Gerald Weinberg-এর The Psychology of Computer Programming (১৯৭১) “egoless programming”-এর কথা বলেছিল: কোড ব্যক্তির সম্পদ নয়, দলের; তাই কোডের ভুল ধরা মানে ব্যক্তিকে আক্রমণ নয়। আজকের blameless culture-এর ধারণাও একই দিকে।

নিচে একটি রাগী মন্তব্য (দলের tracker-এ অনেকে ইংরেজিতে লেখেন) ধাপে ধাপে কাজের bug report-এ রূপ নিচ্ছে:

মূল মন্তব্যরাগ, তথ্য নেই
Coupon is broken AGAIN.
Who wrote this?? Did
anyone even test it?
ধাপ ২ব্যক্তি বাদ, product
Coupon gives a discount
on an order of exactly
1000 taka.
ধাপ ৩পুনরায় ঘটানোর ধাপ
Steps:
1. Cart total = 1000
2. Apply coupon
3. Open checkout
Build: staging, 16 Nov
ধাপ ৪প্রত্যাশিত বনাম আসল
Rule: above 1000 → 10%
Expected discount: 0
Actual discount:  100
1001 → 100 (correct)
চূড়ান্তনিরপেক্ষ, কাজের
Title: Coupon applied at
exactly 1000 taka
Severity (suggested):
  Major
Steps / expected / actual
as above. Happy to add a
boundary test together.
  1. মূল মন্তব্য। তিনটি বাক্যে তিনটি সমস্যা: “AGAIN” দিয়ে খোঁটা, “Who wrote this” দিয়ে ব্যক্তিকে আক্রমণ, আর কোন অর্ডারে কী ঘটেছে তার একটি তথ্যও নেই। Developer এখান থেকে কাজ শুরু করতে পারবেন না, শুধু আত্মরক্ষায় যাবেন।
  2. ব্যক্তিকে বাদ দিন, আচরণ লিখুন। কে লিখেছেন সেই প্রশ্ন সরিয়ে লেখা হলো product কী করছে। Bug ব্যক্তির নয়, product-এর।
  3. কীভাবে ঘটানো যায়। ধাপগুলো এমনভাবে লিখুন যাতে অন্য কেউ হুবহু একই ফল পান: cart-এর মোট, কী চাপলেন, কোন build. পুনরায় ঘটানো না গেলে bug ঠিক করাও যায় না।
  4. প্রত্যাশিত বনাম আসল, উৎসসহ। প্রত্যাশা কোথা থেকে এলো তা লিখুন: requirement-এর নিয়ম। ১০০১ টাকার ফলও দিলে বোঝা যায় সমস্যাটি ঠিক সীমায়; এতে developer দ্রুত কারণ খুঁজে পান।
  5. নিরপেক্ষ শিরোনাম আর সহযোগিতা। শিরোনাম শুধু আচরণ বলে। Severity “প্রস্তাবিত”, চূড়ান্ত সিদ্ধান্ত দলের। শেষ লাইনটি জানায়, tester প্রতিপক্ষ নন, সহকর্মী। পর্ব ১৮-এ পূর্ণ bug report আর defect lifecycle দেখবেন।

আরও গভীরে: defect clustering-এর ধারণাটির পেছনে গবেষণার ধারা লম্বা। ISTQB এটির উৎস হিসেবে ১৯৭৫ সালের একটি বিশ্লেষণ উদ্ধৃত করে (Albert Endres-এর, একটি IBM operating system-এর ভুল নিয়ে)। পরে Fenton আর Ohlsson (২০০০) একটি বড় telecom system-এ দেখান যে অল্প module-এ বেশিরভাগ fault থাকে, কিন্তু আগের release-এর বেশি fault পরের release-এর বেশি fault-এর নির্ভরযোগ্য ভবিষ্যদ্বাণী সবসময় নয়। এই ধারা থেকেই এসেছে defect prediction model, যা কোড বদলের পরিমাণ, জটিলতা আর ইতিহাস দিয়ে ঝুঁকিপূর্ণ file চিহ্নিত করার চেষ্টা করে। Trade-off: model কোথায় test করবেন বলতে পারে, কিন্তু যেখানে কখনো test হয়নি সেখানকার ঝুঁকি data-য় ধরা পড়ে না।

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

  • সাতটি নীতি বলুন। — উপস্থিতি দেখায়; exhaustive অসম্ভব; early testing; defect clustering; tests wear out; প্রসঙ্গ-নির্ভর; absence-of-defects fallacy.
  • Pesticide paradox কী, প্রতিকার? — একই test বারবার নতুন bug ধরে না; test আর data হালনাগাদ, নতুন test, তবে regression-এর জন্য পুরোনোও রাখা।
  • Developer কেন নিজের কোড test করলে যথেষ্ট নয়? — confirmation bias; স্বাধীন চোখ ভিন্ন ধরনের ভুল ধরে; তবে developer-এর test-ও দরকারি।
  • সব test পাস, release করবেন? — test কী ঢেকেছে, কী ঢাকেনি, ঝুঁকি কোথায়, আর validation হয়েছে কি না দেখে সিদ্ধান্ত।
  • “১:১০:১০০” কি সত্য? — বহুল উদ্ধৃত ধারণা, প্রমাণ মিশ্র; তবে শুরুর ভুল পরের কাজে ছড়ায়, তাই early testing লাভজনক।

৯ · AI-এর যুগে সাতটি নীতি

AI assistant কয়েক সেকেন্ডে test লিখে দেয়। কিন্তু সাতটি নীতির প্রায় প্রতিটি AI-লেখা test-এর বেলায় আরও জোরালোভাবে খাটে। AI প্রায়ই শুধু happy path-এর test লেখে, যা §৭-এর লেখকের test-এর মতো: সব পাস, সীমার bug অক্ষত। AI প্রায়ই কোড পড়ে কোড যা করে সেটিকেই প্রত্যাশিত ফল হিসেবে বসায়; তখন coupon_discount(1000)-এর জন্য সে লিখবে 100, আর ভুল কোডেও test সবুজ থাকবে। এটি confirmation bias-এর যান্ত্রিক রূপ। AI “সব test পাস করেছে” বলতে পারে না চালিয়েই; অনুপস্থিত API ঘর বা tool option বানিয়ে বলতে পারে; অপেক্ষার জন্য sleep বসিয়ে অস্থির test বানাতে পারে; বা এত বেশি mock করতে পারে যে আসল কিছুই test হয় না।

AI-কে test লিখতে বললে কোড নয়, requirement দিন, আর সীমা ও negative case স্পষ্ট করে চান:

নিচের requirement থেকে Python unittest-এ test case লিখুন। কোড দেখে প্রত্যাশিত ফল ঠিক করবেন না, শুধু requirement থেকে। Requirement: ১০০০ টাকার বেশি অর্ডারে ১০% ছাড়, সর্বোচ্চ ৩০০ টাকা; ছাড় পূর্ণ টাকায় নিচের দিকে। ১. প্রতিটি সীমার মান (999, 1000, 1001, 3000, 3010) আলাদা test-এ রাখুন। ২. প্রতিটি test-এর পাশে মন্তব্যে লিখুন requirement-এর কোন অংশ যাচাই করছে। ৩. কোন প্রশ্নে requirement অস্পষ্ট মনে হয়েছে, আলাদা তালিকা দিন। ৪. Test চালিয়েছেন বলে দাবি করবেন না; আমি নিজে চালাব।

AI-লেখা test হাতে পেলে — যাচাইয়ের চেকলিস্ট

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

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

প্র ০১Testing যদি কখনো bug-এর অনুপস্থিতি প্রমাণ করতে না পারে, তাহলে বিমান বা চিকিৎসা যন্ত্রের মতো জায়গায় মানুষ software-এর ওপর আস্থা রাখে কীভাবে?

প্রশ্নটি পুরোনো। ১৯৬৯ সালে NATO-র software engineering সম্মেলনে Edsger Dijkstra যে কথাটি বলেন, তার একটি রূপ সম্মেলনের রিপোর্টে আছে (Buxton আর Randell-এর সম্পাদনায় ১৯৭০ সালে প্রকাশিত): testing bug-এর উপস্থিতি দেখাতে পারে, অনুপস্থিতি নয়। ISTQB-এর syllabus আজও প্রথম নীতির উৎস হিসেবে সেই রিপোর্টই উদ্ধৃত করে। Dijkstra-র নিজের উত্তর ছিল গাণিতিক যুক্তি দিয়ে প্রোগ্রামের সঠিকতা প্রমাণ করা।

বাস্তবে আস্থা আসে কয়েকটি স্তর একসাথে জুড়ে, যার কোনোটিই একা যথেষ্ট নয়:

  • কঠোর মান আর প্রক্রিয়া: বিমানের software-এর মান DO-178C-তে সবচেয়ে গুরুতর স্তরে requirement-ভিত্তিক test, কোডের গঠন ঢাকার কঠোর মাপ (যেমন MC/DC, পর্ব ১৩), আর কিছু যাচাই স্বাধীনভাবে করার শর্ত আছে।
  • Formal verification: কিছু অংশের জন্য গাণিতিক প্রমাণ বা solver দিয়ে সব সম্ভাব্য অবস্থা যাচাই। ডিসক্রিট ম্যাথ কোর্সের পর্ব ৭৭-এ এর একটি স্বাদ আছে। প্রমাণও শুধু spec-এর সাথে মেলায়; spec ভুল হলে প্রমাণিত কোডও ভুল কাজ করবে।
  • নকশায় নিরাপত্তা: ভুল হবেই ধরে নিয়ে watchdog, একাধিক স্বাধীন হিসাব, নিরাপদ অবস্থায় থেমে যাওয়া।
  • ব্যবহারের অভিজ্ঞতা: দীর্ঘ সময় ব্যবহারে failure-এর হার মাপা। Ariane 5-এর ১৯৯৬ সালের দুর্ঘটনা দেখায়, পুরোনো অভিজ্ঞতা নতুন প্রসঙ্গে খাটে না।

অর্থাৎ testing-এর লক্ষ্য “প্রমাণ” নয়, বরং ঝুঁকি গ্রহণযোগ্য মাত্রায় নামানো, আর সেই মাত্রা প্রসঙ্গ ঠিক করে: অনলাইন দোকানের জন্য যা যথেষ্ট, পেসমেকারের জন্য তা হাস্যকর রকম কম।

মূল উপলব্ধি: আস্থা একটি স্তূপের মতো, যার প্রতিটি ইট (test, review, প্রমাণ, নকশা, অভিজ্ঞতা) অসম্পূর্ণ; একসাথে তারা ঝুঁকি কমায়, কিন্তু শূন্যে নামায় না।

প্র ০২“Production-এ ধরা bug-এর খরচ requirement-এ ধরার ১০০ গুণ” — এই দাবি কোথা থেকে এলো, আর কেন এটিকে সাবধানে ব্যবহার করা উচিত?

ধারণাটির শিকড় ১৯৭০-৮০-র দশকের বড় সরকারি ও প্রতিরক্ষা project-এ, যেখানে নকশা থেকে delivery পর্যন্ত বছর লাগত আর একটি বদল মানে কাগজের দলিল, পুনরায় অনুমোদন আর হার্ডওয়্যারের সাথে নতুন সমন্বয়। Barry Boehm-এর Software Engineering Economics (১৯৮১) এমন data-র ভিত্তিতে দেখান, পরের ধাপে ধরা পড়া ভুলের খরচ বহুগুণ। Boehm আর Basili ২০০১ সালে লেখেন, delivery-র পরে খুঁজে ঠিক করা প্রায়ই প্রায় ১০০ গুণ ব্যয়বহুল, তবে ছোট, কম গুরুত্বপূর্ণ system-এ অনুপাত ৫:১-এর কাছাকাছি।

সমস্যা শুরু হয় যখন এই সতর্কতা বাদ দিয়ে সংখ্যাটি হাতবদল হয়। Laurent Bossavit তাঁর The Leprechauns of Software Engineering-এ এমন অনেক বহুল উদ্ধৃত লেখচিত্রের উৎস খুঁজতে গিয়ে দেখান, অনেকগুলো আসলে আগের বইয়ের উদ্ধৃতির উদ্ধৃতি; মূল data হয় ছোট, নয়তো পাওয়াই যায় না। Tim Menzies, William Nichols, Forrest Shull আর Lucas Layman ২০১৭ সালে ১৭১টি project-এর data-তে দেরিতে ঠিক করা issue-র বাড়তি খরচের কোনো প্রমাণ পাননি। তাঁরা নিজেরাই সতর্ক করেন: project-গুলো একটি নির্দিষ্ট পদ্ধতিতে চলত, তাই ফল সব জায়গায় খাটবে এমন নয়।

তাহলে কি early testing-এর যুক্তি ভেঙে গেল? না, যুক্তিটি শুধু “গুণক”-এর ওপর দাঁড়িয়ে নেই। এক, requirement-এর ভুল পরের সব কাজে ঢোকে; সময়মতো ধরলে সেই সব কাজ বাঁচে। দুই, production-এর ক্ষতির বড় অংশ developer-এর ঘণ্টায় মাপা যায় না: ভুল ছাড়, ক্রেতার আস্থা, আইনি ঝুঁকি। তিন, আধুনিক continuous delivery-তে ধাপগুলো ছোট আর দ্রুত, তাই “দেরি” মানে মাস নয়, হয়তো কয়েক ঘণ্টা; সেখানে গুণকও ছোট।

পেশাদার জীবনে এর ব্যবহার: বাজেট চাইতে “১০০ গুণ” বলবেন না; বলুন আপনার নিজের দলের data কী বলে (production bug ঠিক করতে গড়ে কত সময়, কত রিফান্ড)। পর্ব ৭৫-এ এমন মাপ দেখবেন।

মূল উপলব্ধি: একটি সত্য ধারণা আর একটি নির্ভুল সংখ্যা এক জিনিস নয়; tester-এর কাজই হলো দাবির প্রমাণ চাওয়া, নিজের পেশার দাবির বেলাতেও।

প্র ০৩Defect clustering জানা থাকলে কি শুধু “খারাপ” module-গুলোই test করা উচিত? এই নীতি কোথায় নিজেকেই ঠকাতে পারে?

Clustering-এর পর্যবেক্ষণ পুরোনো। ISTQB যে উৎস উদ্ধৃত করে, তা ১৯৭৫ সালের একটি IBM operating system-এর ভুলের বিশ্লেষণ। Glenford Myers ১৯৭৯ সালে তাঁর বইয়ে প্রায় একই কথা নীতি হিসেবে লেখেন: কোনো অংশে যত বেশি ভুল পাওয়া গেছে, সেখানে আরও ভুল থাকার সম্ভাবনা তত বেশি। পরে Fenton আর Ohlsson (২০০০, IEEE Transactions on Software Engineering) একটি বড় telecom system-এ দেখান, অল্প কিছু module-এ বেশিরভাগ fault থাকে।

কিন্তু শুধু খারাপ module test করার তিনটি ফাঁদ আছে:

  • খোঁজার পক্ষপাত: যেখানে বেশি খোঁজা হয়, সেখানেই বেশি পাওয়া যায়। কম test হওয়া module-এর তালিকায় শূন্য মানে “জানা নেই”, “নেই” নয়। শুধু ইতিহাস ধরে চললে এই অন্ধ জায়গা কখনো আলোয় আসে না।
  • ভবিষ্যৎ অতীতের মতো নয়: Fenton আর Ohlsson-এর data-তে আগের release-এ বেশি fault পাওয়া module সবসময় পরের release-এর বেশি fault-ওয়ালা ছিল না। নতুন feature, নতুন দল বা বড় refactoring clustering-এর মানচিত্র বদলে দেয়। বাজারঘর নতুন OTP login চালু করলে login হঠাৎ সবচেয়ে ঝুঁকিপূর্ণ হতে পারে।
  • সংখ্যা বনাম ঘনত্ব বনাম প্রভাব: বড় module-এ বেশি defect স্বাভাবিক। ঘনত্ব ভঙ্গুরতা দেখায়। আর একটিমাত্র defect-ও যদি টাকার হিসাবে হয়, তার প্রভাব দশটি বানান-ভুলের চেয়ে বেশি।

সঠিক ব্যবহার: clustering-কে risk-based testing-এর একটি ইনপুট হিসেবে নিন, সাথে নতুন বদলের পরিমাণ, ব্যবসায়িক প্রভাব আর জটিলতা। ঝুঁকিপূর্ণ জায়গায় বেশি গভীরতা, বাকিগুলোতে হালকা কিন্তু নিয়মিত পাহারা, আর মাঝে মাঝে কম test হওয়া এলাকায় exploratory session. বাজারঘরে যেমন, নতুন OTP login-এর release-এ login-এর test বাড়ানোর পাশাপাশি coupon আর delivery-র regression অক্ষুণ্ণ রাখা।

মূল উপলব্ধি: Data দেখায় কোথায় আগুন লেগেছিল; কোথায় পরের আগুন লাগবে, তা জানতে data-র সাথে বিচারবুদ্ধিও লাগে।

প্র ০৪Myers বলেছিলেন programmer-এর নিজের প্রোগ্রাম test করা উচিত নয়; আজকের agile দলে developer-ই প্রচুর test লেখেন। কে ঠিক?

Glenford Myers-এর The Art of Software Testing (১৯৭৯)-এর নীতির তালিকায় এমন একটি কথা আছে: programmer-এর নিজের প্রোগ্রাম test করা এড়ানো উচিত, আর একটি প্রতিষ্ঠানের নিজের প্রোগ্রাম test করাও এড়ানো উচিত। যুক্তি মনস্তাত্ত্বিক: নিজের সৃষ্টি ভাঙার চেষ্টা মানুষের স্বভাববিরুদ্ধ, আর নিজের ভুল বোঝাবুঝি নিজের test-এও থেকে যায়। এর আট বছর আগে Gerald Weinberg (১৯৭১) উল্টো দিক থেকে একই সমস্যা দেখেছিলেন: কোডকে নিজের অহংকারের অংশ ভাবলে review-এ ভুল ধরা ব্যক্তিগত আক্রমণ মনে হয়। তাঁর egoless programming-এর প্রস্তাব ছিল কোডকে দলের সম্পদ বানানো।

১৯৯০-এর দশকের শেষে Extreme Programming আর পরে agile আন্দোলন developer-দের হাতে automated test তুলে দেয়: test-first, প্রতিটি বদলে পুরো suite. এতে বিশাল লাভ হয়েছে, কারণ developer নিজের কোড সবচেয়ে ভালো চেনেন আর মিনিটে feedback পান। ISTQB-এর syllabus-ও স্বীকার করে, independence পরিচিতির বিকল্প নয়; developer-রা নিজের কোডে অনেক defect দক্ষতার সাথে খুঁজে পান।

দুই অবস্থান আসলে ভিন্ন প্রশ্নের উত্তর। Developer-এর unit test প্রশ্ন করে “আমি যা বানাতে চেয়েছি, তা কি বানিয়েছি?” এখানে confirmation bias-এর ঝুঁকি থাকে: §৭-এর লেখকের test-এর মতো, requirement-এর ভুল বোঝাবুঝি কোড আর test দুটিতেই একই রকম থাকে। স্বাধীন tester প্রশ্ন করেন “যা বানানো উচিত ছিল, তা কি বানানো হয়েছে, আর কোথায় ভাঙে?” তাই ISTQB-এর পরামর্শ একাধিক স্তর। আর safety-critical ক্ষেত্রে, যেমন বিমানের software-এর মানে, কিছু যাচাই স্বাধীনভাবে করার শর্তই থাকে।

Agile দলে independence প্রায়ই আসে অন্য পথে: pair programming, code review, three amigos আলোচনা (পর্ব ৭৬), আর দলের ভেতরে test-মনস্ক একজন সদস্য।

মূল উপলব্ধি: প্রশ্ন “কে test করবেন” নয়; প্রশ্ন হলো test-এ যথেষ্ট ভিন্ন দৃষ্টিভঙ্গি আছে কি না, যাতে লেখকের অন্ধ জায়গা অন্য কারও চোখে পড়ে।

প্র ০৫Test-এর ধার কমে যাওয়া ঠেকাতে শিল্পে কোন কৌশলগুলো জন্ম নিয়েছে, আর প্রতিটি কোন ফাঁক পূরণ করে?

Boris Beizer ১৯৯০ সালে “pesticide paradox” নাম দেওয়ার আগেই সমস্যাটি পরিচিত ছিল, আর এর উত্তরে কয়েকটি আলাদা ধারা গড়ে ওঠে। প্রতিটি পুরোনো test-এর একটি নির্দিষ্ট দুর্বলতা লক্ষ্য করে।

  • Mutation testing (test-এর test): ১৯৭৮ সালে DeMillo, Lipton আর Sayward-এর “Hints on Test Data Selection” প্রবন্ধে ধারণাটি পরিচিতি পায়: কোডে ইচ্ছা করে ছোট ভুল ঢুকিয়ে দেখা হয় test suite সেটি ধরে কি না। যে ভুল কোনো test ধরে না, সেটি suite-এর অন্ধ জায়গা দেখায়। §৫-এর বাংলা “ঢাকা”-র মতো ফাঁক এভাবেই চোখে পড়ে। পর্ব ৫৯-এ নিজে চালাবেন।
  • Fuzz testing (এলোমেলো input): ১৯৯০ সালে Barton Miller ও তাঁর ছাত্ররা এলোমেলো input দিয়ে Unix-এর বহু command-line utility চালিয়ে দেখান, উল্লেখযোগ্য একটি অংশ crash করে বা আটকে যায়। হাতে বাছা data যে ঘরগুলো কখনো ছোঁয় না, যন্ত্র সেখানে পৌঁছায়। পর্ব ৬০-এ।
  • Exploratory testing: Cem Kaner ১৯৮০-র দশকে নামটি জনপ্রিয় করেন; পরে session-based পদ্ধতি একে মাপা যায় এমন রূপ দেয়। মানুষের কৌতূহল প্রতিবার নতুন পথে হাঁটে, script-এর পুনরাবৃত্তি থেকে মুক্ত। পর্ব ১৪ আর ২০-এ।
  • Property-based testing: নির্দিষ্ট উদাহরণের বদলে একটি নিয়ম (যেমন “ছাড় কখনো ৩০০-র বেশি নয়”) লিখে যন্ত্রকে হাজারো input বানাতে দেওয়া। পর্ব ৫৮-এ।
  • Production থেকে শেখা: ব্যবহারকারীর আসল আচরণ আর বাস্তব failure থেকে নতুন test case বানানো (পর্ব ৬৬)।

লক্ষ করুন, কোনো কৌশলই পুরোনো regression suite বাতিল করে না। পুরোনো test পাহারাদার, নতুন কৌশল অনুসন্ধানকারী; দুটোই দরকার। বাজারঘরে যেমন, delivery-র পুরোনো দুটি test প্রতিদিন চলুক, আর প্রতি release-এ বাংলা নাম বা নতুন জেলার জন্য একটি exploratory session যোগ হোক।

মূল উপলব্ধি: সবুজ test suite প্রশ্ন তোলে না; ভালো দল নিয়মিত এমন উপায় যোগ করে যা suite-কে নিজেই চ্যালেঞ্জ করে।

অনুশীলন

খাতা-কলমে করুন; উত্তর খোলার আগে নিজের উত্তর লিখে রাখুন।

  1. Test design, নীতি মেনে: বাজারঘরের phone number ঘরের (কাল্পনিক) নিয়ম: ঠিক ১১টি অঙ্ক, শুরু 01 দিয়ে, তৃতীয় অঙ্ক 3 থেকে 9. (ক) সব সম্ভাব্য ১১ অঙ্কের সারি কতটি, আর বৈধ কতটি? (খ) Exhaustive testing অসম্ভব জেনে ৮টির মতো test case বাছুন, যাতে happy path আর negative test দুটোই থাকে।

    (ক) প্রতিটি ঘরে ১০টি অঙ্ক, তাই ১০১১টি সারি, অর্থাৎ দশ হাজার কোটি। বৈধ: প্রথম দুটি স্থির (01), তৃতীয়টির ৭টি বিকল্প (3–9), বাকি ৮টি ঘরে ১০টি করে, অর্থাৎ ৭ × ১০৮, মানে ৭০ কোটি (scratch script-এ মেলানো)। এগুলোর প্রতিটি আলাদা করে test করা সম্ভব নয়।

    (খ) একটি সম্ভাব্য বাছাই:

    • 01712345678 — বৈধ, মাঝের তৃতীয় অঙ্ক (happy path)
    • 01312345678 আর 01912345678 — তৃতীয় অঙ্কের দুই সীমা, বৈধ
    • 01212345678 — তৃতীয় অঙ্ক 2, সীমার ঠিক বাইরে, অবৈধ
    • 0171234567 (১০ অঙ্ক) আর 017123456789 (১২ অঙ্ক) — দৈর্ঘ্যের সীমা
    • 02712345678 — ভুল শুরু
    • 0171234567a বা ফাঁকা ঘর — অঙ্ক ছাড়া অক্ষর, খালি input

    শেষের পাঁচটি negative test; শুধু প্রথমটি দিয়ে test করলে confirmation bias-এর ফাঁদে পড়তেন। বাংলা অঙ্কে (০১৭…) লিখলে কী হবে, সেটি একটি স্পষ্ট প্রশ্ন হিসেবে product owner-কে জিজ্ঞেস করার মতো (early testing). পর্ব ৭ আর ৮-এ এই বাছাইয়ের নিয়মমাফিক কৌশল শিখবেন।

  2. আউটপুট অনুমান করুন: Delivery charge-এর পুরোনো দুটি test (“Dhaka” হলে 60, “Rajshahi” হলে 120) এই নতুন কোডে চালানো হলো: return 60 if district.strip() == "Dhaka" else 150. TextTestRunner(verbosity=1) কী ছাপবে? কোন নীতি এখানে কাজ করছে?

    আসল ফল (scratch-এ চালানো, traceback ছাঁটা):

    .F
    FAIL: test_outside (__main__.Old.test_outside)
    …
    AssertionError: 150 != 120
    
    Ran 2 tests in 0.001s
    
    FAILED (failures=1)

    প্রথম test (Dhaka) পাস, তাই একটি বিন্দু; দ্বিতীয়টি fail, তাই F. বার্তায় প্রথমে কোডের আসল ফল ১৫০, পরে প্রত্যাশিত ১২০. এখানে পুরোনো test-এর ধার কমেনি: বদলটি ঠিক সেই আচরণে, যা পুরোনো test পাহারা দেয়। এটিই regression test-এর কাজ। Tests wear out মানে পুরোনো test অকেজো নয়; মানে তারা শুধু পুরোনো প্রশ্নের উত্তর দেয়। .strip()-এর নতুন আচরণ (যেমন " Dhaka ") কোনো test যাচাই করছে না; সেজন্য নতুন test লাগবে।

  3. Bug report-এর ভুল খুঁজুন: একজন নতুন tester লিখলেন: “Title: Developer broke coupon!!! — আমি ১০০০ টাকার অর্ডারে ১০০ টাকা ছাড় পেয়েছি, এটা ঠিক আছে। কিন্তু ৫০০০ টাকায় ৫০০ পাওয়ার কথা, পেয়েছি ৩০০। Severity: Blocker. দ্রুত ঠিক করুন।” অন্তত চারটি সমস্যা দেখান।
    • দোষারোপের শিরোনাম: “Developer broke” ব্যক্তিকে লক্ষ্য করে; শিরোনামে শুধু আচরণ থাকা উচিত।
    • প্রত্যাশা requirement-এর বিরুদ্ধে: নিয়ম বলে “১০০০ টাকার বেশি”, তাই ঠিক ১০০০-এ ছাড় ০; ১০০ পাওয়াটাই আসল bug, অথচ tester লিখেছেন “ঠিক আছে”। আবার সর্বোচ্চ ছাড় ৩০০, তাই ৫০০০-এ ৩০০ সঠিক; যেটিকে bug বলা হয়েছে সেটি bug নয়। প্রত্যাশিত ফল কোড বা অনুমান থেকে নয়, লিখিত নিয়ম থেকে নিতে হয় (test oracle).
    • পুনরায় ঘটানোর ধাপ নেই: কোন build, cart-এ কী, coupon কীভাবে দেওয়া হলো, কিছুই নেই।
    • Severity অতিরঞ্জিত: “Blocker” সাধারণত মানে কাজ পুরোপুরি আটকে আছে; এখানে বড়জোর একটি সীমার হিসাবের ভুল। Severity প্রস্তাব করুন, যুক্তিসহ।
    • এক report-এ দুটি বিষয়, আর হুকুমের সুর: প্রতিটি bug আলাদা report-এ; “দ্রুত ঠিক করুন” অগ্রাধিকারের সিদ্ধান্ত, যা দল নেয়।

    সংশোধিত রূপ §৮-এর stepper-এর চূড়ান্ত ধাপের মতো; ৫০০০ টাকার অংশটি বাদ।

  4. Pareto আর প্রসঙ্গ: বাজারঘরের পরের release-এর (বানানো) defect: login 21, checkout 9, admin-stock 6, search 5, cart 4, coupon 3, delivery 2. এই release-এই OTP দিয়ে নতুন login চালু হয়েছে। (ক) Cumulative % হিসাব করুন; কয়টি module-এ ৮০% ছাড়ায়? (খ) পরের release-এ test-এর পরিকল্পনায় কী বদলাবেন, আর কোন ভুল সিদ্ধান্ত এড়াবেন?

    (ক) মোট ৫০. চলমান: login ২১ (৪২%), checkout ৩০ (৬০%), admin-stock ৩৬ (৭২%), search ৪১ (৮২%), cart ৪৫ (৯০%), coupon ৪৮ (৯৬%), delivery ৫০ (১০০%). চারটি module-এ ৮০% ছাড়ায় (scratch-এ মেলানো)।

    (খ) login-এর লাফ নতুন feature-এর কারণে, তাই পরের release-এও login-এ গভীর test রাখুন, বিশেষ করে OTP-র সময়সীমা, ভুল OTP, বারবার চেষ্টা। কিন্তু দুটি ভুল এড়ান: (১) আগের release-এ coupon আর delivery ছিল সবচেয়ে ঘন defect-এর জায়গা; এবার সংখ্যা কম মানে হয়তো কম test হয়েছে, তাই ওগুলোর regression ছাঁটবেন না, কারণ ওখানেই টাকার হিসাব। (২) একটি release-এর data দিয়ে স্থায়ী নিয়ম বানাবেন না; বদলের পরিমাণ আর ব্যবসায়িক প্রভাবও দেখুন (প্রসঙ্গ-নির্ভরতা)।

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

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

ক্রমDefect data থেকে test-এর অগ্রাধিকার ঠিক করার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. প্রতিটি module-এ পাওয়া defect গোনা
  2. বেশি থেকে কম ক্রমে সাজানো
  3. ওপর থেকে চলমান যোগফল আর cumulative % বের করা
  4. কোন সারিতে ৮০% ছোঁয় আর ঘনত্ব কোথায় বেশি, দেখা
  5. ঝুঁকিপূর্ণ module-এ বেশি test ও review পরিকল্পনা করা, বাকিগুলোতে হালকা পাহারা রাখা

একটি দল ছয় মাস ধরে প্রতিদিন একই ২০০টি automated test চালায়; সব সবুজ, অথচ ব্যবহারকারীরা নিয়মিত নতুন bug জানাচ্ছেন। কোন নীতি এটি সবচেয়ে ভালো ব্যাখ্যা করে?

  • Defect clustering
  • Tests wear out (pesticide paradox)
  • Early testing
  • Testing প্রসঙ্গ-নির্ভর

কোন বক্তব্যটি “testing defect-এর উপস্থিতি দেখায়, অনুপস্থিতি নয়” নীতির বিরোধী?

  • একটি test fail করলে নিশ্চিত হওয়া যায় যে কোথাও সমস্যা আছে
  • বেশি ও ভালো test অজানা defect থাকার সম্ভাবনা কমায়
  • সব test পাস মানে বাছাই করা input-গুলোতে ভুল পাওয়া যায়নি
  • সব ৫০০টি test পাস করেছে, তাই software-এ আর কোনো bug নেই

একটি অনলাইন দোকানের checkout কোড লিখেছে developer দল; প্রতিষ্ঠানের ভেতরের কিন্তু সেই দলের বাইরের একটি QA দল system test করছে। ISTQB-এর syllabus অনুযায়ী এটি independence-এর কোন স্তর?

  • No independence
  • Some independence
  • High independence
  • Very high independence

নিয়ম: “১০০০ টাকার বেশি অর্ডারে ১০% ছাড়”। লেখক test করলেন শুধু ১৫০০, ৫০০০ আর ৫০০ টাকা দিয়ে; সব পাস। কিন্তু কোডে >= লেখা থাকায় ঠিক ১০০০ টাকায় ভুল ছাড় যাচ্ছে। লেখকের test বাছাইয়ে কোন মানসিক ঝোঁক সবচেয়ে স্পষ্ট?

  • Confirmation bias
  • Pesticide paradox
  • Defect clustering
  • Absence-of-defects fallacy

“Requirement-এ ধরা defect ঠিক করতে খরচ ১ হলে production-এ ১০০” — এই দাবির সবচেয়ে সঠিক মূল্যায়ন কোনটি?

  • এটি সব project-এ মাপা একটি নির্দিষ্ট সর্বজনীন পরিসংখ্যান
  • এটি বহুল উদ্ধৃত মোটা দাগের ধারণা; প্রমাণ মিশ্র, প্রসঙ্গভেদে অনুপাত খুব আলাদা
  • এটি সম্পূর্ণ মিথ্যা, দেরিতে ধরা bug-এ কোনো বাড়তি খরচ নেই
  • এটি ISTQB-এর একটি আনুষ্ঠানিক আইন

একটি অনলাইন দোকানের app spec-এর সব test পাস করেছে, কোনো খোলা defect নেই। কিন্তু delivery charge শুধু শেষ ধাপে দেখানোয় ক্রেতারা বিরক্ত হয়ে cart ছেড়ে যাচ্ছেন। এটি কোন নীতির উদাহরণ?

  • Exhaustive testing অসম্ভব
  • Defect clustering
  • Absence-of-defects fallacy
  • Tests wear out

শব্দকোষ

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

মনে রাখুন

  1. সাতটি নীতি অভিজ্ঞতার সারকথা: উপস্থিতি দেখায়, exhaustive অসম্ভব, early testing, clustering, tests wear out, প্রসঙ্গ, absence-of-defects fallacy.
  2. Test পাস মানে বাছাই করা input-এ ভুল পাওয়া যায়নি; “কোনো bug নেই” নয়, আর “সফল product”-ও নয়।
  3. Defect জমাট বাঁধে, কিন্তু ৮০/২০ মাপা সংখ্যা নয়; সংখ্যা আর ঘনত্ব দুটো দেখুন, কম test হওয়া জায়গা ভুলবেন না।
  4. কোড বদলালে নতুন test লিখুন, পুরোনোগুলো regression হিসেবে রাখুন। “১:১০:১০০” প্রমাণে দুর্বল, তবে শুরুর ভুল পরের কাজে ছড়ায়।
  5. Confirmation bias কমাতে ভিন্ন চোখ আর negative test; bug-এর খবর দিন তথ্য দিয়ে, দোষ দিয়ে নয়।

পরের পর্বে: নীতি জানলেন; এবার দেখবেন testing software তৈরির পুরো যাত্রার কোথায় বসে: waterfall, V-model আর agile-এ tester-এর জায়গা, STLC-র ধাপ, আর shift-left মানে কোড লেখার আগেই requirement-এর অস্পষ্টতা ধরা।

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

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