এই পর্বে যা শিখবেন
- সংখ্যার পরিসর, নির্দিষ্ট তালিকা (set), লেখার ধাঁচ (string format) আর একাধিক input থেকে partition বের করার নিয়মমাফিক পদ্ধতি
- প্রতিনিধি বাছাই, expected result ঠিক করা আর ID-সহ test case টেবিল লেখা — তারপর সেটিকে আসল
unittest-এ বদলে seeded defect ধরা - Each-choice, base-choice আর সব-মিশ্রণ — কোনটিতে কয়টি test, আর কেন invalid মান একবারে একটি
- Output partition, partition coverage-এর হিসাব, আর লুকানো ও overlap করা partition-এর ফাঁদ
- AI-কে দিয়ে partition বানালে কোথায় ভুল হয়, আর কীভাবে যাচাই করবেন
১ · চালের বস্তা থেকে এক মুঠো — EP-র মূল ভাবনা
কারওয়ান বাজারে চালের আড়তে গিয়ে কেউ পুরো বস্তা ঢেলে প্রতিটি দানা দেখেন না। বস্তার মুখ থেকে এক মুঠো চাল হাতে নিয়ে দেখেন: ভাঙা দানা কত, কাঁকর আছে কি না, গন্ধ কেমন। এক মুঠো দিয়ে পুরো বস্তার বিচার চলে, কারণ ধরে নেওয়া হয় বস্তার সব চাল একই ধানের, একই মিলের। কিন্তু অভিজ্ঞ ক্রেতা জানেন, অসৎ বিক্রেতা ওপরে ভালো চাল আর নিচে খারাপ চাল রাখতে পারেন। তখন এক মুঠো মিথ্যা বলে। তাই তিনি কখনো বস্তার নিচ থেকেও এক মুঠো তোলেন।
Software testing-এ এই বুদ্ধিরই নাম equivalence partitioning (সংক্ষেপে EP). পর্ব ০২-এ (Testing কী) হিসাব করে দেখেছেন, বাজারঘরের checkout form-এর মাত্র তিনটি ঘরের সব মিশ্রণ test করতে কোটি কোটি বছর লাগবে। পর্ব ০৩-এর (সাতটি নীতি) দ্বিতীয় নীতিও তাই বলে: exhaustive testing অসম্ভব। তাহলে কোন অল্প কয়েকটি input বেছে নেবেন? EP-র উত্তর: input-জগৎকে এমন কয়েকটি দলে ভাগ করুন, যাদের প্রতিটির ভেতরের সব মানের সঙ্গে software-এর একই আচরণ করার কথা। তারপর প্রতিটি দল থেকে একটি মান — এক মুঠো চাল।
রান্নায় ডাল লবণ ঠিক হলো কি না দেখতে পুরো হাঁড়ি খেতে হয় না, এক চামচ চেখে দেখাই যথেষ্ট — যদি ডাল ভালো করে নাড়া হয়ে থাকে। না নাড়লে ওপরে পানসে, নিচে নোনতা। EP-র সব শক্তি আর সব দুর্বলতা এই “ভালো করে নাড়া”-র অনুমানে। দলের ভেতরে সত্যিই এক আচরণ হলে এক মান যথেষ্ট; দলের ভেতরে লুকানো ভিন্নতা থাকলে সেই এক মান ভুলটি দেখতে পায় না।
EP একটি test design technique, অর্থাৎ নিয়ম মেনে test বেছে নেওয়ার পদ্ধতি। এটি black-box কৌশল: কোড না দেখে শুধু requirement বা অন্য test basis থেকে কাজ করে। তাই manual tester কোড না জেনেই এটি ব্যবহার করতে পারেন, আর automation engineer একই টেবিলকে কয়েক লাইনের কোডে বদলে দিতে পারেন। দুজনের জন্যই এই পর্ব।
Equivalence partitioning প্রথম গুছিয়ে বই আকারে আসে Glenford Myers-এর The Art of Software Testing (১৯৭৯)-এ; সেখানে “equivalence class” নামে, invalid class আলাদা করে লেখার নিয়মসহ। পরে Boris Beizer domain testing নামে একই চিন্তা আরও গাণিতিকভাবে বিস্তার করেন। আজকের প্রচলিত সংজ্ঞা পাওয়া যায় ISO/IEC/IEEE 29119-4 মানে (প্রথম সংস্করণ ২০১৫) আর ISTQB-এর Foundation syllabus-এ। সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৪৭-এ EP একটি অংশে সংক্ষেপে এসেছে; এখানে পুরো পদ্ধতি, নানা ধরনের input, হিসাব আর ফাঁদসহ অনেক গভীরে যাব।
২ · Partition কী — valid, invalid আর তিনটি শর্ত
প্রথমে শব্দগুলো স্পষ্ট করি। একটি equivalence partition (বাংলায় “সমতুল্য দল”, পুরোনো বইয়ে equivalence class) হলো input বা output মানের এমন একটি অংশ, যার সব মানকে test basis একইভাবে সামলাতে বলে। বাজারঘরের কুপনের নিয়মটি মনে করুন:
ছাড় পূর্ণ টাকায়, ভগ্নাংশ বাদ; শুধু পণ্যের দামে, ডেলিভারি চার্জে নয়।
অর্ডারের মোট (পণ্যের দাম, পূর্ণ টাকায়) নিয়ে নিয়মটি তিন রকম আচরণ বলে: ১০০০ বা কম হলে ছাড় নেই; ১০০১ থেকে ৩০০০-এ ১০%; তার বেশি হলে ৩০০-তে আটকে যায়। কারণ ৩০০০-এর ১০% ঠিক ৩০০, আর ৩০০১ থেকে ১০% হয় ৩০০-র বেশি, তাই নিয়মের সীমা কাজ শুরু করে (ভগ্নাংশ বাদ দেওয়ায় ফলের তফাত প্রথম দেখা যায় ৩০১০-এ; পর্ব ০৮)। এই তিনটি valid partition: এগুলো গ্রহণযোগ্য input, শুধু ফল আলাদা। আর যে input গ্রহণ করার কথাই নয় — শূন্য বা ঋণাত্মক মোট, ভগ্নাংশ টাকা — সেগুলো invalid partition; এদের দিয়ে করা test হলো negative test.
কুপনের input-জগৎ পাঁচটি দলে
ওপরে প্রতিটি দলের আচরণ, নিচে বাছাই করা প্রতিনিধি; রেখাটি মাপ অনুযায়ী নয়
একটি ভালো partition-ভাগের তিনটি শর্ত আছে। গণিতে একে বলে set-এর partition, আর testing-এও অর্থ একই:
- প্রতিটি দল খালি নয়: দলে অন্তত একটি মান থাকতে হবে, নইলে প্রতিনিধি বাছাই করা যাবে না।
- দলগুলো আলাদা (disjoint): একটি মান দুটি দলে থাকতে পারবে না। “০–১০০০” আর “১০০০–৩০০০” লিখলে ১০০০ দুই দলে পড়ে, আর তার expected result কী, টেবিল দেখে বলা যায় না।
- দলগুলো মিলে সব ঢাকে (complete): সম্ভাব্য প্রতিটি input কোনো না কোনো দলে পড়বে। ভগ্নাংশ টাকা কোনো দলে না থাকলে সেটি পরীক্ষার বাইরে থেকে যায়।
EP-র coverage item হলো partition নিজে: প্রতিটি চিহ্নিত দল একটি করে “ঢাকতে হবে” এমন জিনিস। কোনো test একটি দলের মান ব্যবহার করলে সেই দল exercised বা ছোঁয়া হলো। আর equivalence partition coverage = (অন্তত একটি test-এ ছোঁয়া দল ÷ চিহ্নিত সব দল) × ১০০%. ISTQB-এর syllabus-এ মোটামুটি এভাবেই বলা আছে, আর valid ও invalid দুই রকম দলই এই হিসাবে গোনা হয়।
খেয়াল করুন, partition হয় শুধু input-এর নয়। Output-কেও দলে ভাগ করা যায় (§৭-এ আসছে), আর সময়, অবস্থা, পরিবেশ — যেকোনো কিছু, যার মান বদলালে software-এর আচরণ বদলানোর কথা। “একই আচরণ” মানে একই ফল নয়: ১৫০০ আর ২৫০০ টাকায় ছাড় আলাদা (১৫০ আর ২৫০), কিন্তু দুটিতেই একই নিয়ম — “১০% কেটে ভগ্নাংশ বাদ” — খাটে। তাই দুটি একই দলে।
৩ · Requirement থেকে partition — ধাপে ধাপে পদ্ধতি
“দলে ভাগ করুন” বলা সহজ, কিন্তু নতুনরা প্রায়ই কয়েকটি দল বাদ দেন বা দুটি দল মিশিয়ে ফেলেন। তাই নিচের ধাপগুলো প্রতিবার একই ক্রমে মেনে চলুন। এটি Myers-এর মূল নির্দেশনা আর আধুনিক মানের সারকথা, নিজের ভাষায়:
- Input আর output চিহ্নিত করুন। কোন কোন ঘর, parameter বা অবস্থা ফলকে প্রভাবিত করে? প্রতিটির জন্য আলাদা কাজ।
- প্রতিটি নিয়মকে আলাদা শর্তে ভাঙুন। “১১ অঙ্ক, শুরু 01, তৃতীয় অঙ্ক 3–9” আসলে চারটি শর্ত: দৈর্ঘ্য, শুধু অঙ্ক, শুরু, তৃতীয় অঙ্ক।
- Valid partition লিখুন। Requirement যেখানে আলাদা আচরণ বলে, সেখানেই আলাদা দল। যেখানে একই আচরণ, সেখানে একটি দল।
- প্রতিটি শর্তের জন্য invalid partition লিখুন। প্রতিটি শর্ত কীভাবে ভাঙতে পারে? পরিসরের নিচে, ওপরে, ভুল ধরন, খালি।
- Overlap আর ফাঁক যাচাই করুন। কোনো মান দুই দলে আছে? কোনো input কোনো দলেই নেই? প্রয়োজনে দল আরও ভাঙুন বা আলাদা করুন।
- প্রতিনিধি আর expected result ঠিক করুন। প্রতিটি দল থেকে একটি মান; ফল আসবে requirement থেকে, কোড থেকে নয়।
- Test-এ সাজান। Valid দলগুলো মিলিয়ে কম test; প্রতিটি invalid দল নিজের আলাদা test-এ, বাকি সব ঘর valid রেখে (§৬)।
Input-এর ধরন অনুযায়ী দল বের করার কয়েকটি পরিচিত ধাঁচ আছে। এগুলো মুখস্থ নয়, শুরুর বিন্দু; শেষ কথা সবসময় requirement-এর:
| Requirement-এর ধরন | Valid দল | Invalid দল | বাজারঘরের উদাহরণ |
|---|---|---|---|
| সংখ্যার পরিসর | পরিসরের ভেতর (আচরণ বদলালে আরও ভাগ) | নিচে, ওপরে, ভুল ধরন (ভগ্নাংশ, অক্ষর) | পণ্যের পরিমাণ 1–10 |
| নির্দিষ্ট তালিকা (set) | প্রতিটি সদস্য আলাদা দল, যদি আচরণ আলাদা হয় | তালিকার বাইরের মান, খালি | পেমেন্ট: cash / mobile-wallet / card |
| লেখার ধাঁচ (format) | ধাঁচ মানা লেখা | প্রতিটি নিয়ম আলাদাভাবে ভাঙা | ফোন নম্বর, পাসওয়ার্ড |
| সংখ্যা গোনা (count) | অনুমোদিত সংখ্যা | কম, বেশি | একটি অর্ডারে সর্বোচ্চ ২০টি পণ্য |
| “অবশ্যই” শর্ত | শর্ত মানা | শর্ত না মানা | ঠিকানার ঘর খালি রাখা যাবে না |
| হ্যাঁ/না (boolean) | হ্যাঁ, না | সাধারণত নেই (UI-তে) | “সদস্য?” চেকবক্স |
এবার ফোন নম্বরের ঘরে পুরো পদ্ধতিটি চালাই। বাজারঘরের (কাল্পনিক) নিয়ম: নম্বর ১১ অঙ্কের, শুরু 01 দিয়ে, তৃতীয় অঙ্ক 3 থেকে 9. “পরে” চাপুন, আর ডানে দলের তালিকা কীভাবে বাড়ছে দেখুন।
| শর্ত | |
| নতুন দল | |
| প্রতিনিধি | |
| মোট দল |
- নিয়ম ভেঙে শর্ত। এক বাক্যের নিয়মে আসলে চারটি আলাদা শর্ত: C1 দৈর্ঘ্য ঠিক ১১, C2 সব অক্ষর অঙ্ক, C3 শুরু 01, C4 তৃতীয় অঙ্ক 3–9. প্রতিটি শর্ত আলাদাভাবে ভাঙতে পারে, তাই প্রতিটি থেকে invalid দল আসবে।
- Valid দল। চারটি শর্তই সত্য হলে নম্বর গ্রহণযোগ্য। তৃতীয় অঙ্ক 7 বা 9 হলে কি আচরণ আলাদা? Requirement তা বলে না, দুটিই শুধু “গ্রহণ”। তাই valid দল একটিই, V1; প্রতিনিধি
01712345678. - দৈর্ঘ্যের দল। C1 ভাঙে দুই দিকে: কম আর বেশি। খালি ঘরও আসলে “কম”, কিন্তু অনেক app খালি ঘরে আলাদা বার্তা দেয় (“নম্বর দিন”)। তাই overlap এড়াতে খালিকে আলাদা দল X1 করে “কম”-কে লিখলাম ১ থেকে ১০ অঙ্ক (X2). বেশি হলো X3, ১২ বা বেশি অঙ্ক।
- চিহ্নের দল। C2 ভাঙে অক্ষর, ফাঁকা জায়গা,
+,--এর মতো চিহ্নে। প্রতিনিধি0171234567a: দৈর্ঘ্য ১১, শুরু 01, তৃতীয় অঙ্ক 7 — অর্থাৎ শুধু C2 ভাঙা। এটিই X4. - শুরুর দল। C3 ভাঙা: ১১টি অঙ্ক, কিন্তু শুরু 01 নয়। প্রতিনিধি
02712345678; তৃতীয় অঙ্ক 7 রাখা হয়েছে, যাতে C4 না ভাঙে। এটি X5. - তৃতীয় অঙ্কের দল। C4 ভাঙা: তৃতীয় অঙ্ক 0, 1 বা 2. প্রতিনিধি
01112345678. এখন মোট ৭টি দল: ১টি valid, ৬টি invalid. - প্রতিনিধি যাচাই। প্রতিটি invalid প্রতিনিধি ঠিক একটি শর্ত ভাঙে কি না দেখুন। কেউ “তৃতীয় অঙ্ক” দলের জন্য
01012345লিখলে সেটি C1-ও ভাঙে (৮ অঙ্ক), ফলে software কোন কারণে প্রত্যাখ্যান করল বোঝা যায় না। এমন প্রতিনিধি বাদ। - নিয়মে যা নেই। বাংলা অঙ্কে
০১৭…, দেশের কোডসহ+880…, মাঝে ফাঁকা দিয়ে017 1234 5678— এগুলো valid না invalid? Requirement চুপ। এই প্রশ্নগুলো মালিককে লিখে পাঠান; উত্তর অনুযায়ী নতুন দল যোগ হবে। Partition বানাতে গিয়ে requirement-এর ফাঁক ধরা পড়া EP-র বড় উপকার।
কোড দেখে partition নয়। Developer হয়তো তৃতীয় অঙ্কের যাচাইয়ে ভুল করে "23456789" লিখেছেন। আপনি কোড দেখে দল বানালে আপনার দলও হবে “তৃতীয় অঙ্ক 2–9 valid”, আর test পাস করবে ভুলসহ। দল আসবে requirement থেকে; কোড শুধু পরে মিলিয়ে দেখার জিনিস।
৪ · প্রতিনিধি বাছাই আর test case টেবিল — কুপন
দল চিহ্নিত হলে প্রতিটি থেকে একটি প্রতিনিধি মান বাছতে হয়। EP-র তত্ত্বে দলের যেকোনো মানই চলে, কারণ সবার আচরণ এক হওয়ার কথা। তবু অভিজ্ঞ tester দুটি অভ্যাস রাখেন। এক, প্রতিনিধি নেন দলের মাঝামাঝি থেকে, কিনারা থেকে নয়: কিনারার মান পরের পর্বের boundary value analysis-এর কাজ, আর EP-র test কিনারায় ব্যর্থ হলে বোঝা যায় না ভুলটি দলের না সীমার। দুই, এমন মান নেন যার ফল হাতে সহজে হিসাব করা যায়, যেমন ২০০০, ১৯৮৭ নয়।
| দল | |
| পরিসর | |
| প্রতিনিধি | |
| expected | |
| test |
- পাঁচটি দল সামনে। ছবি ৭.১-এর দলগুলো: X1 (০ বা কম), V1 (১–১০০০), V2 (১০০১–৩০০০), V3 (৩০০১ বা বেশি), X2 (ভগ্নাংশ)। এখনো কোনো test নেই, তাই coverage ০%.
- V1 থেকে ৫০০. মাঝামাঝি, হিসাব সহজ। Requirement বলে ১০০০ বা কম হলে ছাড় নেই, তাই expected ০. একটি দল ছোঁয়া হলো: ১/৫ = ২০%.
- V2 থেকে ২০০০. ২০০০-এর ১০% = ২০০, সীমার নিচে, ভগ্নাংশও নেই। Expected ২০০. এই হিসাব হাতে requirement থেকে করা, কোড চালিয়ে নয়। এখন ২/৫ = ৪০%.
- V3 থেকে ৫০০০. ১০% হলে ৫০০, কিন্তু সর্বোচ্চ ৩০০; তাই expected ৩০০. ৩/৫ = ৬০%.
- দুটি invalid দল। X1 থেকে
-50, X2 থেকে1500.5. Requirement বলে মোট পূর্ণ টাকার ধনাত্মক সংখ্যা; ধরে নিচ্ছি বাজারঘরের নকশায় এমন input এলে functionValueErrorদেয়। প্রতিটি আলাদা test-এ। এখন ৫/৫ = ১০০%. - টেবিল তৈরি, কিন্তু সাবধান। ৫টি test-এ ১০০% partition coverage. তবু ১০০০ আর ১০০১-এর পার্থক্য, বা ৩০০০ আর ৩০০১-এর পার্থক্য কোনো test দেখেনি। কোডে
>-এর বদলে>=থাকলে এই ৫টি test-ই পাস করবে। সেই ভুল ধরার কৌশল পর্ব ০৮-এ (Boundary value analysis — দুই-মান আর তিন-মান পদ্ধতি)।
Manual tester-এর হাতে কাজের ফল একটি test case টেবিল। প্রতিটি সারিতে ID, input, expected result আর কোন দল ঢাকছে (coverage item) — যাতে যে কেউ পড়ে বুঝতে পারেন কেন এই test আছে:
| ID | Input (মোট, টাকা) | Expected | কৌশল / coverage item |
|---|---|---|---|
| CP-01 | 500 | ছাড় 0 | EP · V1 (1–1000) |
| CP-02 | 2000 | ছাড় 200 | EP · V2 (1001–3000) |
| CP-03 | 5000 | ছাড় 300 | EP · V3 (3001+) |
| CP-04 | -50 | ValueError | EP · X1 (≤ 0) |
| CP-05 | 1500.5 | ValueError | EP · X2 (ভগ্নাংশ) |
এবার automation engineer-এর পালা: এই টেবিলকেই unittest-এ বদলাই। নিচের কোডে কুপনের function-এ ইচ্ছা করে একটি ভুল (seeded defect) রাখা আছে: সীমা ৩০০-র বদলে ৩০০০ টাইপ করা হয়েছে, এক শূন্য বেশি। টেবিলের প্রতিটি সারি একটি subTest, তাই কোন দলে ভুল ধরা পড়ল, আউটপুটেই তার ID থাকবে। পুরোটা চলবে আপনার ব্রাউজারে (Pyodide); “চালান” চাপুন।
import sys, unittest
# Code under test, with one seeded defect: the cap is typed as 3000.
def coupon_discount(total):
if not isinstance(total, int) or total <= 0:
raise ValueError("total must be a positive whole number")
if total > 1000:
return min(total * 10 // 100, 3000)
return 0
# Partitions come from the requirement; one representative each.
VALID = [ # (id, partition, representative, expected)
("V1", "1..1000", 500, 0),
("V2", "1001..3000", 2000, 200),
("V3", "3001 or more", 5000, 300),
]
INVALID = [("X1", "0 or less", -50), ("X2", "not whole", 1500.5)]
class CouponEP(unittest.TestCase):
def test_valid_partitions(self):
for pid, part, value, expected in VALID:
with self.subTest(pid, value=value):
self.assertEqual(coupon_discount(value), expected)
def test_invalid_partitions(self):
for pid, part, value in INVALID:
with self.subTest(pid, value=value):
with self.assertRaises(ValueError):
coupon_discount(value)
suite = unittest.defaultTestLoader.loadTestsFromTestCase(CouponEP)
r = unittest.TextTestRunner(verbosity=2, stream=sys.stdout).run(suite)
print("partitions:", len(VALID) + len(INVALID), "| failed:", len(r.failures))আসল আউটপুট (ব্রাউজারের Python):
test_invalid_partitions (__main__.CouponEP.test_invalid_partitions) ... ok
test_valid_partitions (__main__.CouponEP.test_valid_partitions) ...
test_valid_partitions (__main__.CouponEP.test_valid_partitions) [V3] (value=5000) ... FAIL
======================================================================
FAIL: test_valid_partitions (__main__.CouponEP.test_valid_partitions) [V3] (value=5000)
----------------------------------------------------------------------
Traceback (most recent call last):
File "main.py", line 23, in test_valid_partitions
self.assertEqual(coupon_discount(value), expected)
~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
AssertionError: 500 != 300
----------------------------------------------------------------------
Ran 2 tests in 0.002s
FAILED (failures=1)
partitions: 5 | failed: 1
দুটি test method চলেছে, কিন্তু ভেতরে পাঁচটি subTest. Invalid দুটি (X1, X2) ok: function সত্যিই ValueError দিয়েছে। Valid দলের মধ্যে শুধু V3 ব্যর্থ, আর আউটপুটের [V3] (value=5000) সরাসরি বলে দিচ্ছে কোন দল আর কোন মান। AssertionError: 500 != 300: function দিয়েছে ৫০০, requirement চায় ৩০০. ভুল সীমাটি (৩০০০) এত বড় যে ৫০০০ টাকার অর্ডারেও কাজ করেনি।
লক্ষ করুন, V1 আর V2-এর প্রতিনিধি এই ভুল কখনো দেখত না: ৫০০ আর ২০০০-এ সীমা কাজই করে না। এই ভুলটি শুধু “সীমা কাজ করে” এমন দলেই দেখা যায় — আর V3 দলটি আলাদা করে চিনেছিলাম বলেই ধরা পড়ল। এটিই EP-র যুক্তি: প্রতিটি ভিন্ন আচরণের অন্তত একটি test. নিজে পরীক্ষা করুন: 3000-কে 300 করে আবার চালান; সব ok হবে। তারপর > 1000-কে >= 1000 করুন — এবারও সব ok! সেই ভুল এই ৫টি test-এর চোখের বাইরে।
৫ · ফোন নম্বর হাতে-কলমে — string-এর দল আর লুকানো দল
সংখ্যার পরিসরে দল চেনা তুলনামূলক সহজ, কারণ সংখ্যা-রেখায় সাজানো যায়। লেখার (string) ঘরে কাজটি কঠিন: দৈর্ঘ্য, চিহ্ন, শুরু, নির্দিষ্ট অবস্থানের অক্ষর — অনেকগুলো মাত্রা একসঙ্গে। §৩-এর stepper-এ পাওয়া সাতটি দল এবার টেবিল আর কোডে:
| ID | দল | প্রতিনিধি | Expected | যে শর্ত ভাঙে |
|---|---|---|---|---|
| PH-01 | V1 | 01712345678 | গ্রহণ | কোনোটি নয় |
| PH-02 | X1 খালি | "" | প্রত্যাখ্যান | C1 (খালি) |
| PH-03 | X2 1–10 অঙ্ক | 0171234567 | প্রত্যাখ্যান | C1 |
| PH-04 | X3 12+ অঙ্ক | 017123456789 | প্রত্যাখ্যান | C1 |
| PH-05 | X4 অঙ্ক ছাড়া চিহ্ন | 0171234567a | প্রত্যাখ্যান | C2 |
| PH-06 | X5 শুরু 01 নয় | 02712345678 | প্রত্যাখ্যান | C3 |
| PH-07 | X6 তৃতীয় অঙ্ক 0–2 | 01112345678 | প্রত্যাখ্যান | C4 |
নিচের validator-এ seeded defect হলো দৈর্ঘ্যের যাচাইয়ে ==-এর বদলে >=. কোডের শেষে তিনটি এমন input-ও চালানো হয়েছে, যেগুলো নিয়মে লেখা নেই — §৩-এর তিনটি খোলা প্রশ্ন।
import sys, unittest
# Code under test, with one seeded defect: ">=" in the length check.
def is_valid_phone(s):
return (len(s) >= 11 and s.isdigit()
and s.startswith("01") and s[2] in "3456789")
CASES = [ # (id, partition, representative, expected)
("V1", "01 + [3-9] + 8 digits", "01712345678", True),
("X1", "empty", "", False),
("X2", "1-10 digits", "0171234567", False),
("X3", "12+ digits", "017123456789", False),
("X4", "non-digit char", "0171234567a", False),
("X5", "not starting 01", "02712345678", False),
("X6", "third digit 0-2", "01112345678", False),
]
class PhoneEP(unittest.TestCase):
def test_each_partition(self):
for pid, part, value, expected in CASES:
with self.subTest(pid, part=part):
self.assertEqual(is_valid_phone(value), expected)
suite = unittest.defaultTestLoader.loadTestsFromTestCase(PhoneEP)
unittest.TextTestRunner(verbosity=2, stream=sys.stdout).run(suite)
# Partitions nobody wrote down (questions for the requirement):
for odd in ["017১২৩৪৫৬৭৮", "+8801712345678", "017 1234 5678"]:
print(repr(odd), "->", is_valid_phone(odd))আসল আউটপুট (ব্রাউজারের Python):
test_each_partition (__main__.PhoneEP.test_each_partition) ...
test_each_partition (__main__.PhoneEP.test_each_partition) [X3] (part='12+ digits') ... FAIL
======================================================================
FAIL: test_each_partition (__main__.PhoneEP.test_each_partition) [X3] (part='12+ digits')
----------------------------------------------------------------------
Traceback (most recent call last):
File "main.py", line 22, in test_each_partition
self.assertEqual(is_valid_phone(value), expected)
~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
AssertionError: True != False
----------------------------------------------------------------------
Ran 1 test in 0.001s
FAILED (failures=1)
'017১২৩৪৫৬৭৮' -> True
'+8801712345678' -> False
'017 1234 5678' -> False
সাতটি দলের মধ্যে শুধু X3 (12+ অঙ্ক) ব্যর্থ: True != False, অর্থাৎ validator ১২ অঙ্কের নম্বর গ্রহণ করেছে। >= ভুলটি শুধু “বেশি অঙ্ক” দলেই দেখা যায়; V1 বা X2-এর কোনো মান এটি দেখত না। বাকি ছয়টি দল পাস করেছে বলে তাদের আউটপুটে আলাদা লাইন নেই; subTest শুধু ব্যর্থগুলো দেখায়।
শেষ তিন লাইন আরও মজার। +880… আর ফাঁকা-সহ নম্বর প্রত্যাখ্যাত হয়েছে, যা requirement-এর আক্ষরিক অর্থের সঙ্গে মেলে (যদিও গ্রাহকের দিক থেকে হয়তো গ্রহণ করাই উচিত — সেটি মালিকের সিদ্ধান্ত)। কিন্তু '017১২৩৪৫৬৭৮' — ইংরেজি আর বাংলা অঙ্ক মেশানো — গ্রহণ করা হয়েছে! কারণ Python-এর str.isdigit() বাংলা অঙ্ককেও অঙ্ক বলে মানে। এই নম্বর database-এ গেলে SMS পাঠানোর system হয়তো ভেঙে পড়বে। কেউ এই দলটি লেখেননি, তাই কোনো test-ও ছিল না। এটিই লুকানো partition: requirement-এ একটি দল মনে হলেও (“অঙ্ক”), বাস্তবে software-এর কাছে দুটি আলাদা জিনিস।
একই ফাঁদ regex-এও: Python 3-এ str-এর regular expression-এ \d যেকোনো Unicode অঙ্কের সঙ্গে মেলে, বাংলা অঙ্কসহ; শুধু 0–9 চাইলে [0-9] লিখতে হয় বা re.ASCII flag দিতে হয় (regex নিয়ে Python প্রোগ্রামিং কোর্সের পর্ব ৩০)। বাংলা লেখা, তারিখ আর সংখ্যার পুরো testing আসবে পর্ব ৫৬-এ (Localization testing — বাংলা Unicode, font, তারিখ আর সংখ্যা)।
৬ · একাধিক input — each-choice, base-choice আর একবারে একটি invalid
বাস্তব form-এ ঘর একাধিক। বাজারঘরের checkout-এর তিনটি ঘর ধরুন: ফোন (১টি valid, ৬টি invalid দল), মোট টাকা (কুপনের ৩টি valid, ২টি invalid) আর জেলা (২টি valid: ঢাকা, বাইরে; ১টি invalid: কিছু বাছাই হয়নি)। দলগুলো কীভাবে মিলিয়ে test বানাবেন? তিনটি প্রচলিত পথ:
সব মিশ্রণ
প্রতিটি ঘরের প্রতিটি দলের সঙ্গে অন্য সব ঘরের প্রতিটি দল। গুণের নিয়মে সংখ্যা দ্রুত ফোলে, আর invalid-এ invalid মেশানো অর্থহীন test-ও তৈরি হয়।
৭ × ৫ × ৩ = ১০৫Each-choice
প্রতিটি ঘরের প্রতিটি দল অন্তত একটি test-এ। Valid দলগুলো এক test-এ মেশানো চলে, তাই valid test লাগে সবচেয়ে বেশি দলওয়ালা ঘরের সমান।
valid ৩ + invalid ৯ = ১২Base-choice
একটি “স্বাভাবিক” base test বাছুন, তারপর একবারে একটি ঘরের দল বদলান, বাকি সব base-এ। প্রতিটি দল একবার “একা” পরীক্ষিত হয়।
১ + ৬ + ৪ + ২ = ১৩Invalid দল নিয়ে নিয়মটি পছন্দের বিষয় নয়: প্রতিটি test-এ সর্বোচ্চ একটি invalid মান, বাকি সব ঘর valid. কেন? বেশিরভাগ form বা function প্রথম ভুল পেয়েই থেমে যায়। দুটি ভুল একসঙ্গে দিলে দ্বিতীয় ঘরের যাচাই আদৌ আছে কি না, test জানতে পারে না — একে বলে error masking বা defect masking. নিচের stepper-এ তিনটি ঘরের একটি checkout দেখুন, যার ভেতরে একটি ভুল আছে: মোট টাকার যাচাই developer লিখতেই ভুলে গেছেন।
| phone | |
| amount | |
| district | |
| expected | |
| actual | |
| রায় |
- Base test. সব ঘরে valid মান: ফোন
01712345678, মোট ১৫০০, জেলা ঢাকা। Checkout কোনো error দেয় না — প্রত্যাশামতো। এটিই base: পরের প্রতিটি test এখান থেকে শুধু একটি ঘর বদলাবে। - শুধু ফোন invalid. ফোন
0171(দল X2), বাকি সব base. Checkout বলে “phone error”. Pass, আর আমরা নিশ্চিত যে error-টি ফোনের কারণেই, কারণ অন্য কিছু বদলায়নি। - শুধু মোট invalid. মোট
-50, বাকি base. Expected “amount error”, কিন্তু checkout কিছুই বলে না, অর্ডার এগিয়ে যায়! FAIL — মোট টাকার যাচাই নেই, ভুলটি ধরা পড়ল। - শুধু জেলা invalid. জেলা বাছাই হয়নি, বাকি base. “district error” — pass.
- শর্টকাটের ফাঁকি। সময় বাঁচাতে কেউ এক test-এ ফোন
0171আর মোট-50দিলেন, আর লিখলেন “কোনো error আসা উচিত”. Checkout ফোনের ভুল দেখেই থামল, “phone error” দিল, test pass. মোট টাকার যাচাই যে নেই, এই test কখনো জানাবে না। এটিই masking. - নিয়ম। প্রতিটি invalid দল নিজের test পায়, বাকি সব ঘর valid. তাই invalid test-এর সংখ্যা = মোট invalid দলের সংখ্যা। Valid দলগুলো মেশানো চলে, কারণ valid মান কোনো error দিয়ে অন্যকে ঢাকে না।
একই ঘটনা এবার আসল কোডে। প্রথম test দুটি invalid একসঙ্গে দেয়, পরের দুটি একবারে একটি:
import sys, unittest
def is_valid_phone(s):
return (len(s) == 11 and s.isdigit()
and s.startswith("01") and s[2] in "3456789")
# Returns the first problem it finds. Seeded defect: the
# amount check was forgotten.
def checkout_error(phone, amount, district):
if not is_valid_phone(phone):
return "phone"
if district not in ("Dhaka", "outside"):
return "district"
return None
GOOD = dict(phone="01712345678", amount=1500, district="Dhaka")
class CheckoutEP(unittest.TestCase):
def test_two_invalids_together(self): # bad design
bad = dict(GOOD, phone="0171", amount=-50)
self.assertIsNotNone(checkout_error(**bad))
def test_invalid_amount_alone(self): # one invalid
bad = dict(GOOD, amount=-50)
self.assertEqual(checkout_error(**bad), "amount")
def test_invalid_phone_alone(self): # one invalid
bad = dict(GOOD, phone="0171")
self.assertEqual(checkout_error(**bad), "phone")
suite = unittest.defaultTestLoader.loadTestsFromTestCase(CheckoutEP)
unittest.TextTestRunner(verbosity=2, stream=sys.stdout).run(suite)আসল আউটপুট (ব্রাউজারের Python):
test_invalid_amount_alone (__main__.CheckoutEP.test_invalid_amount_alone) ... FAIL
test_invalid_phone_alone (__main__.CheckoutEP.test_invalid_phone_alone) ... ok
test_two_invalids_together (__main__.CheckoutEP.test_two_invalids_together) ... ok
======================================================================
FAIL: test_invalid_amount_alone (__main__.CheckoutEP.test_invalid_amount_alone)
----------------------------------------------------------------------
Traceback (most recent call last):
File "main.py", line 25, in test_invalid_amount_alone
self.assertEqual(checkout_error(**bad), "amount")
~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
AssertionError: None != 'amount'
----------------------------------------------------------------------
Ran 3 tests in 0.000s
FAILED (failures=1)
test_two_invalids_together ok — অথচ কোডে বড় ভুল আছে। এই test একা থাকলে CI সবুজ দেখাত। test_invalid_amount_alone ব্যর্থ: None != 'amount', অর্থাৎ ঋণাত্মক মোট নিয়েও checkout কোনো সমস্যা দেখেনি। একই input (-50) দুটি test-এই আছে; পার্থক্য শুধু সঙ্গে আরেকটি invalid মান আছে কি না। এখানে base-এর ধারণাও দেখুন: dict(GOOD, amount=-50) মানে “base থেকে শুধু একটি ঘর বদলাও”. Automation-এ এই কৌশল পর্ব ২৩-এ (Fixture আর test data — scope, factory আর builder) আরও গুছিয়ে আসবে।
Valid দল মেশানোর ঝুঁকি: each-choice-এ valid দলগুলো এলোমেলো জোড়ায় মেলে, যেমন “৩০০১+ টাকা” পড়ল “ঢাকা”-র সঙ্গে আর “বাইরে” পড়ল “১০০১–৩০০০”-এর সঙ্গে। দুটি ঘরের মিলনে ভুল থাকলে (ধরুন শুধু “ঢাকার বাইরে + বড় অর্ডার”-এ ডেলিভারি ভুল) each-choice সেটি না-ও দেখতে পারে। ঘরগুলোর মধ্যে নিয়মের সম্পর্ক থাকলে decision table (পর্ব ০৯), আর অনেক ঘরের জোড়া ঢাকতে pairwise (পর্ব ১১)।
৭ · Output partition আর coverage-এর হিসাব
এতক্ষণ input ভাগ করেছি। কিন্তু অনেক সময় output দেখে দল চেনা আরও কাজের। বাজারঘরের ডেলিভারি চার্জের নিয়ম: ঢাকার ভেতরে ৬০ টাকা, বাইরে ১২০ টাকা; অর্ডার ২০০০ টাকা বা বেশি হলে ঢাকার ভেতরে ফ্রি। Output তিন রকম: ০, ৬০, ১২০. এগুলো তিনটি output partition. Input-এর দিক থেকে each-choice করলে দুটি valid test-ই যথেষ্ট মনে হয়: (ঢাকা, ১৫০০) আর (বাইরে, ২৫০০)। এতে জেলার দুটি দল আর মোটের দুটি দল সব ছোঁয়া হলো। কিন্তু ফল আসে ৬০ আর ১২০ — “ফ্রি ডেলিভারি” (০) কখনো দেখা হয়নি! Output দল ঢাকতে তৃতীয় test (ঢাকা, ২৫০০) লাগে।
কুপনেও output-এর দল আছে: ছাড় ০, ছাড় ১০০ থেকে ২৯৯ (১০%), আর ঠিক ৩০০. একটি সূক্ষ্ম কথা: output “৩০০” আসে ৩০০০ টাকা থেকেই, কারণ ৩০০০-এর ১০% নিজেই ৩০০; নিয়মের সীমা কাজ শুরু করে ৩০০১ থেকে (ভগ্নাংশ বাদ দেওয়ায় ৩০০৯ পর্যন্ত ফল একই ৩০০)। অর্থাৎ input-এর দলের সীমা (৩০০০/৩০০১) আর output-এর দলের সীমা (২৯৯৯/৩০০০) একই জায়গায় নয়। সীমার এমন হিসাব পর্ব ০৮-এর বিষয়, কিন্তু দেখুন, output দিয়ে ভাবলে requirement-এর আরেকটি দিক চোখে পড়ে।
এবার সংখ্যাগুলো হাতে না গুনে কোডে গুনি — পরীক্ষায় আর ইন্টারভিউতে ঠিক এই হিসাবগুলোই আসে। নিচের কোড checkout-এর তিন ঘরের দল থেকে সব-মিশ্রণ, each-choice আর base-choice test গোনে, each-choice test-গুলো সত্যিই তৈরি করে, আর partition coverage মাপে।
from math import prod
# Checkout form: partitions per field (v = valid, x = invalid)
FIELDS = {
"phone": {"v": ["V1"], "x": ["X1", "X2", "X3", "X4", "X5", "X6"]},
"amount": {"v": ["1-1000", "1001-3000", "3001+"], "x": ["<=0", "frac"]},
"district": {"v": ["Dhaka", "outside"], "x": ["none"]},
}
total = sum(len(f["v"]) + len(f["x"]) for f in FIELDS.values())
print("partitions in all fields :", total)
print("every partition combined :", prod(len(f["v"]) + len(f["x"]) for f in FIELDS.values()))
print("valid combinations only :", prod(len(f["v"]) for f in FIELDS.values()))
# Each-choice: valid values share tests; each invalid gets its own test.
k = max(len(f["v"]) for f in FIELDS.values())
tests = [{n: f["v"][i % len(f["v"])] for n, f in FIELDS.items()} for i in range(k)]
for name, f in FIELDS.items():
for bad in f["x"]:
t = {n: g["v"][0] for n, g in FIELDS.items()}
t[name] = bad
tests.append(t)
print("each-choice tests :", len(tests))
base = 1 + sum(len(f["v"]) + len(f["x"]) - 1 for f in FIELDS.values())
print("base-choice tests :", base)
def coverage(test_set):
seen = {(n, t[n]) for t in test_set for n in FIELDS}
return 100 * len(seen) / total
print(f"coverage, all tests : {coverage(tests):.1f}%")
print(f"coverage, first 4 tests : {coverage(tests[:4]):.1f}%")
for t in tests[:4]:
print(" ", t)আসল আউটপুট (ব্রাউজারের Python):
partitions in all fields : 15
every partition combined : 105
valid combinations only : 6
each-choice tests : 12
base-choice tests : 13
coverage, all tests : 100.0%
coverage, first 4 tests : 46.7%
{'phone': 'V1', 'amount': '1-1000', 'district': 'Dhaka'}
{'phone': 'V1', 'amount': '1001-3000', 'district': 'outside'}
{'phone': 'V1', 'amount': '3001+', 'district': 'Dhaka'}
{'phone': 'X1', 'amount': '1-1000', 'district': 'Dhaka'}
তিন ঘরে মোট ১৫টি দল (৭ + ৫ + ৩)। সব দলের সব মিশ্রণ ৭ × ৫ × ৩ = ১০৫ (গুণের নিয়ম; গণনার মূল নিয়ম ডিসক্রিট ম্যাথ কোর্সের পর্ব ৩১-এ)। শুধু valid দলের মিশ্রণ ১ × ৩ × ২ = ৬. Each-choice-এ valid test ৩টি (সবচেয়ে বেশি valid দল “amount”-এর ৩টি), আর invalid দল ৬ + ২ + ১ = ৯টি, প্রতিটির আলাদা test: মোট ১২. Base-choice-এ ১টি base, তারপর প্রতিটি ঘরে base ছাড়া বাকি দলগুলো: ১ + (৭−১) + (৫−১) + (৩−১) = ১৩.
১২টি test-এ coverage ১০০%. প্রথম ৪টিতে মাত্র ৪৬.৭%: সেখানে ছোঁয়া হয়েছে V1, তিনটি amount দল, দুটি জেলা আর X1 — ৭টি, আর ৭ ÷ ১৫ = ০.৪৬৭. Coverage-এর হিসাব হয় দল গুনে, test গুনে নয়: চতুর্থ test একটি নতুন দল (X1) যোগ করেছে, প্রথম তিনটি মিলে ছয়টি।
| কী গুনছেন | সূত্র (ঘর i-তে vi valid, xi invalid দল) | checkout-এ |
|---|---|---|
| মোট দল | Σ (vi + xi) | 15 |
| সব দলের সব মিশ্রণ | ∏ (vi + xi) | 105 |
| Each-choice + একবারে একটি invalid | max(vi) + Σ xi | 3 + 9 = 12 |
| Base-choice | 1 + Σ (vi + xi − 1) | 13 |
| Partition coverage | ছোঁয়া দল ÷ মোট দল × 100% | 7/15 = 46.7% |
দুই রকম coverage গুলিয়ে ফেলবেন না। Partition coverage মাপে requirement-এর মডেল কতটা ঢাকা হলো; কোড কতটা চলল, তা নয়। কোডের statement বা branch coverage আলাদা জিনিস — সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৫০-এ সংক্ষেপে, আর এই কোর্সে পর্ব ১৩-এ গভীরে। ১০০% partition coverage-এও কোডের একটি শাখা অছোঁয়া থাকতে পারে, আবার ১০০% branch coverage-এও requirement-এর একটি দল বাদ পড়তে পারে।
৮ · ফাঁদ — লুকানো দল, overlap আর EP-র সীমা
EP সহজ দেখায়, কিন্তু পেশাদার জীবনে এর ভুলগুলো বারবার একই রকম। পাঁচটি সবচেয়ে পরিচিত:
| ফাঁদ | বাজারঘরে উদাহরণ | প্রতিকার |
|---|---|---|
| লুকানো দল | বাংলা অঙ্কের ফোন নম্বর; জেলার নাম “ঢাকা” বাংলায় লেখা; “Dhaka ” শেষে ফাঁকা | প্রতিটি দলে প্রশ্ন করুন: “এর ভেতরে software কি সত্যিই সবাইকে এক চোখে দেখে?” Encoding, ভাষা, ফাঁকা জায়গা, বড়-ছোট হাতের অক্ষর আলাদা করে ভাবুন |
| Overlap | “০–১০০০ ছাড় নেই” আর “১০০০–৩০০০ ১০%” | প্রতিটি সীমার মান কোন দলে, লিখে নিশ্চিত করুন; “বেশি” আর “বা বেশি”-র পার্থক্য requirement-এ মিলিয়ে নিন |
| দুই শর্ত ভাঙা প্রতিনিধি | “তৃতীয় অঙ্ক” দলের জন্য 01012345 (দৈর্ঘ্যও ভুল) | প্রতিটি invalid প্রতিনিধি ঠিক একটি শর্ত ভাঙবে |
| কোড থেকে দল | কোডে "23456789" দেখে তৃতীয় অঙ্ক 2-কেও valid ধরা | দল requirement থেকে; অস্পষ্ট হলে প্রশ্ন, অনুমান নয় |
| দলের ভেতরে ভাগ করা কোড | উপরের ভুলে প্রতিনিধি 01112345678 প্রত্যাখ্যাত হয় (ঠিকঠাক), কিন্তু 012… গৃহীত হয় | ঝুঁকিপূর্ণ দলে একাধিক মান; সীমায় BVA; বড় ঝুঁকিতে random বা property-based input |
শেষ সারিটি EP-র মৌলিক সীমা দেখায়। EP একটি অনুমানের ওপর দাঁড়িয়ে: দলের ভেতরে software একইভাবে আচরণ করে। Developer যদি দলের ভেতরে একটি আলাদা পথ বানিয়ে ফেলেন (ভুল করে বা জেনে-বুঝে), সেই দলের এক প্রতিনিধি সেই পথে পড়তেও পারে, না-ও পারে। X6 দলে (তৃতীয় অঙ্ক 0, 1, 2) “0” আর “1” প্রত্যাখ্যাত, কিন্তু ভুল কোডে “2” গৃহীত — আপনার প্রতিনিধি 1 হলে test পাস, ১০০% partition coverage, আর ভুলটি অক্ষত। তাই EP একা নয়, সঙ্গে আরও কৌশল লাগে: সীমার জন্য পর্ব ০৮, অভিজ্ঞতা থেকে সন্দেহজনক মানের জন্য পর্ব ১৪ (অভিজ্ঞতাভিত্তিক testing), অনেক এলোমেলো মানের জন্য পর্ব ৫৮ (Property-based testing), আর test-গুলো আসলে কতটা শক্ত, তা মাপতে পর্ব ৫৯ (Mutation testing).
আরও গভীরে: EP আসলে কতটা ভালো, তা নিয়ে গবেষণায় বিতর্ক পুরোনো। Duran ও Ntafos (১৯৮৪) দেখান, random testing অনেক ক্ষেত্রে partition testing-এর প্রায় সমান কাজ করে; Hamlet ও Taylor (১৯৯০)-এর প্রবন্ধের নামই ছিল “Partition testing does not inspire confidence”. Weyuker ও Jeng (১৯৯১) গাণিতিকভাবে দেখান, partition testing random-এর চেয়ে ভালো, সমান বা খারাপ — সবই হতে পারে, নির্ভর করে ব্যর্থ input-গুলো দলে কীভাবে ছড়ানো তার ওপর; দলগুলো যত “একই রকম” (ভেতরে হয় সব ব্যর্থ, নয় সব সফল), partition তত শক্তিশালী। শিল্পে এর সুসংগঠিত রূপ Ostrand ও Balcer-এর (১৯৮৮) category-partition method: category, choice আর তাদের মধ্যে constraint লিখে test-এর বিবরণ যন্ত্রে তৈরি করা।
পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন প্রায়ই আসে:
- বয়স 18–60 পূর্ণসংখ্যা — কয়টি partition? — সংখ্যার দিক থেকে ৩টি (নিচে, ভেতরে, ওপরে); ধরনের দিক থেকে আরও (অক্ষর, ভগ্নাংশ, খালি)।
- Invalid মান কেন একবারে একটি? — error masking: প্রথম ভুলে থেমে গেলে দ্বিতীয় যাচাইয়ের ফল দেখা যায় না।
- ৮টি দলের ৬টি ছোঁয়া হলে coverage? — ৬ ÷ ৮ = ৭৫%.
- ঘরগুলোতে valid দল ৪, ৩, ২ (invalid নেই) — each-choice-এ সর্বনিম্ন কয়টি test? — ৪, সবচেয়ে বেশি দলওয়ালা ঘরের সমান।
- EP আর BVA-র পার্থক্য? — EP দলের যেকোনো একটি মান নেয়; BVA দলের কিনারা আর তার পাশের মান নেয়, কারণ ভুল প্রায়ই সীমায়।
৯ · AI-এর যুগে equivalence partitioning
AI assistant-কে “এই ফোন নম্বর validator-এর test লেখো” বললে কয়েক সেকেন্ডে দশটি test পাবেন। সমস্যা হলো, সংখ্যা দেখে মান বোঝা যায় না। AI প্রায়ই শুধু happy path আর দু-একটি সহজ invalid মান দেয়; কোড দেখে দল বানায়, ফলে কোডের ভুল দলেও ঢুকে যায়; কোড যা ফেরত দেয় সেটিকেই expected result বসায়, তাই ভুল কোডেও test সবুজ; এক test-এ একাধিক invalid মান মেশায়; সীমার মানগুলো বাদ দেয়; বাংলা অঙ্ক বা +880-এর মতো লুকানো দল কল্পনাও করে না; আর “সব test পাস করেছে” বলে, কখনো না চালিয়েই। কখনো এমন unittest method-এর নামও লেখে, যা আসলে নেই।
AI-কে কোড নয়, requirement দিন, আর দলগুলো আগে টেবিলে চান — test পরে:
AI-এর বানানো partition আর test হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১দলে ভাগ করে test বাছাই কি সত্যিই এলোমেলো input-এর চেয়ে ভালো? গবেষণা কী বলে?
শুনতে অবাক লাগলেও, প্রশ্নটি নিয়ে আশির দশক থেকে গবেষকেরা গুরুতর বিতর্ক করেছেন। ১৯৮৪ সালে Joe Duran আর Simeon Ntafos IEEE Transactions on Software Engineering-এ random testing-এর একটি মূল্যায়ন প্রকাশ করেন। তাঁদের simulation আর পরীক্ষায় দেখা যায়, সমান সংখ্যক test হলে এলোমেলো input অনেক ক্ষেত্রে partition-ভিত্তিক test-এর প্রায় সমান সংখ্যক ভুল ধরে, আর খরচ অনেক কম, কারণ দল চিনতে মানুষের সময় লাগে না। ১৯৯০ সালে Dick Hamlet আর Ross Taylor আরও এগিয়ে প্রবন্ধের নামই দেন “Partition testing does not inspire confidence”.
তারপর ১৯৯১ সালে Elaine Weyuker আর Bingchiang Jeng বিষয়টি গাণিতিকভাবে বিশ্লেষণ করেন। তাঁদের মূল ফল: partition testing random testing-এর চেয়ে ভালো, সমান বা খারাপ — তিনটিই হতে পারে। কোনটি হবে, নির্ভর করে ব্যর্থ input-গুলো দলে কীভাবে ছড়িয়ে আছে তার ওপর। যদি একটি দলের ভেতরে হয় সব input ব্যর্থ, নয় সব সফল (দল “homogeneous”), তাহলে প্রতিটি দলের একটি প্রতিনিধিই নিশ্চিতভাবে ভুল ধরে, আর partition অনেক এগিয়ে। কিন্তু দলগুলো যদি requirement-এর ভাষায় বানানো আর কোডের আসল পথের সঙ্গে না মেলে, তখন প্রতিনিধি বাছাই প্রায় লটারি, আর random-এর চেয়ে বেশি সুবিধা থাকে না।
বাজারঘরের ভাষায়: কুপনের V3 দল (৩০০১+) homogeneous, সেখানে সীমার ভুল থাকলে যেকোনো প্রতিনিধি ধরবে — যেমনটি কোড চালিয়ে দেখলেন। কিন্তু ফোনের X6 দলে ভুল কোড “2”-কে আলাদা করে ফেলেছিল, তখন দলটি আর homogeneous নয়। বাস্তব পেশাদার উত্তর তাই “হয় এটা, নয় ওটা” নয়। EP দেয় নিয়মমাফিক, ব্যাখ্যাযোগ্য, পর্যালোচনা করা যায় এমন test; random বা property-based test দেয় অনেক বেশি মান, যা মানুষের অনুমানের বাইরের জায়গাও ছোঁয় (পর্ব ৫৮)। দুটি মিলিয়েই আধুনিক test suite.
মূল উপলব্ধি: EP-র শক্তি দলের মানের সমান। ভালো দল মানে এমন দল, যার ভেতরে সত্যিই এক আচরণ; সেটি নিশ্চিত করতে requirement পড়া, প্রশ্ন করা আর সন্দেহজনক দলে বাড়তি মান — এগুলোই tester-এর আসল দক্ষতা।
প্র ০২Ariane 5 রকেটের ১৯৯৬ সালের দুর্ঘটনাকে “লুকানো partition”-এর গল্প বলা যায় কেন?
১৯৯৬ সালের ৪ জুন ইউরোপের নতুন Ariane 5 রকেট প্রথম উড্ডয়নের প্রায় ৪০ সেকেন্ড পরে পথ হারিয়ে ভেঙে যায়, আর নিজেকে ধ্বংস করে। তদন্ত বোর্ডের (J. L. Lions-এর নেতৃত্বে) প্রতিবেদন অনুযায়ী, কারণ ছিল দিক নির্ণয়ের যন্ত্রের (inertial reference system) software-এ একটি সংখ্যা রূপান্তর: ৬৪-বিটের একটি দশমিক মান (অনুভূমিক বেগের সঙ্গে সম্পর্কিত) ১৬-বিটের signed integer-এ বদলানোর সময় মানটি সেই ঘরের ধারণক্ষমতার (৩২,৭৬৭) চেয়ে বড় হয়ে যায়। Exception-টি ধরা ছিল না, দুটি যন্ত্রই (মূল আর বিকল্প, একই software) বন্ধ হয়ে যায়।
মজার বিষয় হলো, এই software আগের Ariane 4 রকেট থেকে নেওয়া, আর সেখানে বছরের পর বছর নির্ভুলভাবে চলেছে। Ariane 4-এর উড্ডয়ন-পথে এই মান কখনো এত বড় হতো না, তাই ঐ রূপান্তরকে নিরাপদ ধরে কয়েকটি ক্ষেত্রে সুরক্ষা রাখা হয়নি। Ariane 5 অনেক দ্রুত, শুরুর দিকে অনুভূমিক বেগ অনেক বেশি। Partition-এর ভাষায়: input-জগতে একটি দল ছিল — “৩২,৭৬৭-এর বেশি মান” — যেটি পুরোনো প্রসঙ্গে বাস্তবে কখনো আসত না, তাই কারও test-এর তালিকায় গুরুত্ব পায়নি। নতুন প্রসঙ্গে সেই দলটিই বাস্তব হয়ে উঠল। প্রতিবেদন এটাও বলে যে ঐ হিসাবটি উড্ডয়নের পরে আর দরকারই ছিল না, আর Ariane 5-এর আসল উড্ডয়ন-পথের data দিয়ে পুরো system-এর পরীক্ষা হলে সমস্যাটি ধরা পড়তে পারত।
শিক্ষাটি বাজারঘরের মতো ছোট app-এও খাটে। জেলার তালিকায় “ঢাকা” আর “বাইরে” দুটি দল ছিল; দোকান চট্টগ্রাম থেকেও পাঠানো শুরু করলে “ভেতরে/বাইরে”-র মানেই বদলে যায়। ফোন নম্বরের নিয়মে নতুন operator এলে নতুন উপসর্গ আসে। Partition কোনো স্থায়ী সত্য নয়; এটি একটি প্রসঙ্গের মডেল (পর্ব ০৩-এর “প্রসঙ্গ” নীতি)। প্রসঙ্গ বদলালে দলও আবার বানাতে হয়, আর পুরোনো test-এর পাশাপাশি নতুন test লাগে।
মূল উপলব্ধি: “এই মান তো কখনো আসবে না” — এই অনুমান নিজেই একটি partition, আর তাকে লিখে রাখা, প্রশ্ন করা আর প্রসঙ্গ বদলালে আবার যাচাই করা দরকার।
প্র ০৩“একবারে একটি invalid” নিয়ম কি সবসময় খাটে? যে form সব ভুল একসঙ্গে দেখায়, সেখানে কী করবেন?
নিয়মটির পেছনের কারণ error masking: system প্রথম ভুল পেয়েই থামলে দ্বিতীয় ভুলের যাচাই অদৃশ্য থাকে। Myers-এর ১৯৭৯ সালের বইয়েই এই নির্দেশনা আছে — প্রতিটি invalid class-এর জন্য এমন test, যা শুধু সেই একটি invalid class ঢাকে। ISTQB-এর syllabus-ও একই সতর্কতা দেয়। Ammann ও Offutt তাঁদের Introduction to Software Testing বইয়ে base-choice coverage নামে একটি সুসংগঠিত রূপ দেন: একটি “স্বাভাবিক” base test বাছাই, তারপর একবারে একটি parameter বদল। এর বাড়তি সুবিধা হলো, কোনো test ব্যর্থ হলে কারণ খুঁজতে হয় না — base থেকে শুধু একটি জিনিসই বদলেছে।
এখন আধুনিক web form ভাবুন, যা “Submit” চাপলে সব ঘরের ভুল একসঙ্গে লাল করে দেখায়। এখানে system প্রথম ভুলে থামে না, তাই masking-এর ঝুঁকি কম মনে হতে পারে। কিন্তু দুটি কারণে নিয়মটি এখনো কাজের। এক, আপনি জানেন না ভেতরে সত্যিই সব যাচাই চলে কি না; browser-এর যাচাই হয়তো সব দেখায়, কিন্তু server-এর API প্রথম ভুলেই থামে। দুই, প্রতিটি ভুলের বার্তা ঠিক কি না (“ফোন নম্বর ১১ অঙ্কের হতে হবে”), সেটি আলাদাভাবে যাচাই করা সহজ হয় আলাদা test-এ।
তাহলে একসঙ্গে একাধিক invalid কখনো দেবেন না? দেবেন, কিন্তু বাড়তি test হিসেবে, যার উদ্দেশ্য আলাদা: “তিনটি ঘর ভুল হলে তিনটি বার্তাই কি দেখায়?” এটি error-গুলো একত্র করার আচরণের test, প্রতিটি যাচাই আছে কি না তার test নয়। নিরাপত্তা আর robustness testing-এও ইচ্ছা করে অনেক ভুল একসঙ্গে পাঠানো হয়, দেখতে system ভেঙে পড়ে কি না (পর্ব ৬০-এর fuzz testing). মূল কথা: প্রতিটি test-এর একটি স্পষ্ট প্রশ্ন থাকবে, আর সেই প্রশ্নের উত্তর যেন অন্য ভুলে ঢাকা না পড়ে।
মূল উপলব্ধি: নিয়মটি আসলে “test প্রতি একটি প্রশ্ন” নীতির রূপ। একাধিক invalid মেশানো চলে কেবল তখন, যখন সেই মিশ্রণটিই প্রশ্ন।
প্র ০৪নাম বা ঠিকানার মতো মুক্ত লেখার ঘরে partition কীভাবে বানাবেন, যেখানে সম্ভাব্য input প্রায় অসীম আর নানা ভাষার?
মুক্ত লেখার ঘর EP-র সবচেয়ে কঠিন জায়গা, কারণ এখানে “একই আচরণ” আগে থেকে স্পষ্ট নয়। ১৯৮৮ সালে Thomas Ostrand আর Marc Balcer Communications of the ACM-এ category-partition method প্রকাশ করেন, যা এমন সমস্যায় শৃঙ্খলা আনে। পদ্ধতিটি হলো: প্রতিটি input-এর জন্য কয়েকটি category লিখুন — বৈশিষ্ট্য, যা আচরণ বদলাতে পারে (দৈর্ঘ্য, লিপি, বিশেষ চিহ্ন, শুরু-শেষের ফাঁকা)। প্রতিটি category-র কয়েকটি choice (দৈর্ঘ্য: খালি, ১ অক্ষর, সাধারণ, সর্বোচ্চ, সর্বোচ্চের বেশি)। তারপর constraint: কোন choice অন্যটির সঙ্গে অর্থহীন, কোনটি একবার দেখলেই যথেষ্ট (তাঁদের ভাষায় [error], [single]). এভাবে লেখা বিবরণ থেকে একটি tool test-এর তালিকা তৈরি করে।
বাজারঘরের “নাম” ঘরে লিপির category বিশেষ জরুরি: বাংলা, ইংরেজি, মিশ্র। বাংলা লেখায় একই দেখতে অক্ষর Unicode-এ একাধিকভাবে লেখা যায় (যেমন যুক্তাক্ষর বা কিছু কার-চিহ্ন ভিন্ন ক্রমে), তাই “একই নাম” দুইভাবে সংরক্ষিত হয়ে খোঁজে মেলে না। আবার দৈর্ঘ্য: software “অক্ষর” গোনে byte-এ, code point-এ না দেখা-অক্ষরে (grapheme)? “ক্ষ” দেখতে একটি অক্ষর, কিন্তু Unicode-এ তিনটি code point (ক, হসন্ত, ষ)। “সর্বোচ্চ ৩০ অক্ষর” requirement-এ এই তিন রকম গোনা তিনটি আলাদা partition-সীমা তৈরি করে। ফোনের ঘরে বাংলা অঙ্ক যেভাবে লুকানো দল হয়ে উঠল, নামের ঘরে তেমনি লুকিয়ে থাকে Unicode-এর এসব খুঁটিনাটি (পর্ব ৫৬)।
বাস্তবে কাজ তাই দুই স্তরে: প্রথমে category-choice টেবিল বানিয়ে প্রতিটি choice অন্তত একবার (each-choice), তারপর ঝুঁকিপূর্ণ জোড়াগুলো pairwise দিয়ে (পর্ব ১১)। আর অসীম জগতের বাকি অংশে এলোমেলো input বা fuzzing নিয়মিত চলুক।
মূল উপলব্ধি: মুক্ত লেখায় partition আসে বৈশিষ্ট্য থেকে, মান থেকে নয়। কোন বৈশিষ্ট্য software-এর আচরণ বদলাতে পারে — এই প্রশ্নের তালিকাই আপনার দলের তালিকা।
প্র ০৫১০০% partition coverage পেলে কি বলা যায় “EP-র কাজ শেষ, এই ঘর ঠিক আছে”?
না, আর কারণটি coverage-এর সংজ্ঞার ভেতরেই আছে। Partition coverage মাপে আপনার চিহ্নিত দলগুলোর কতটা ঢাকা হলো। হর (denominator) আপনি নিজে ঠিক করেছেন। একটি দল চোখ এড়ালে সেটি হরেই নেই, আর ১০০% তখনও ১০০%. ফোনের উদাহরণে বাংলা অঙ্কের দল কেউ লেখেননি; সাতটি দলের সাতটিই ঢাকা, coverage ১০০%, অথচ মিশ্র অঙ্কের নম্বর গৃহীত হচ্ছিল। ISO/IEC/IEEE 29119-4 মানেও প্রতিটি কৌশলের coverage মাপা হয় সেই কৌশলের মডেলের সাপেক্ষে — মডেল যত ভালো, সংখ্যাটি তত অর্থবহ।
দ্বিতীয় কারণ, এক দলের এক প্রতিনিধি দলের ভেতরের বৈচিত্র্য দেখে না। তৃতীয় অঙ্কের দলে ভুল কোড শুধু “2”-কে ভিন্নভাবে দেখলে, প্রতিনিধি “1” সেটি ধরবে না। তৃতীয় কারণ, সীমা: EP মাঝামাঝি মান নেয়, তাই > আর >=-এর ভুল প্রায় কখনো দেখে না। চতুর্থ, মিশ্রণ: each-choice ঘরগুলোর জোড়ার ভুল দেখে না।
তাহলে test আসলে কতটা শক্ত, কীভাবে মাপবেন? একটি শক্তিশালী উপায় হলো কোডে ইচ্ছা করে ছোট ছোট ভুল বসিয়ে (mutant) দেখা, আপনার test-গুলো কয়টি ধরে — এই পর্বের প্রতিটি code block ঠিক সেটিই করেছে একটি করে seeded defect দিয়ে। কাজটি যন্ত্র দিয়ে বড় পরিসরে করার নাম mutation testing, আর তার হিসাব mutation score (পর্ব ৫৯)। ভুলগুলো কৃত্রিম হলেও গবেষণায় দেখা গেছে, mutant ধরতে পারা test সাধারণত আসল ভুল ধরতেও বেশি সক্ষম। Partition coverage তাই একটি ন্যূনতম শর্ত: ১০০%-এর কম হলে জানা দলই বাদ পড়েছে; ১০০% হলে প্রশ্ন শুরু হয় — আর কোন দল আমি দেখিনি?
মূল উপলব্ধি: Coverage সংখ্যা বলে “যা মাপতে চেয়েছি, তার কতটা মেপেছি”; “যা আছে, তার কতটা দেখেছি” — সেটি বলে না। দ্বিতীয় প্রশ্নের উত্তর খোঁজাই tester-এর চিন্তার কাজ।
অনুশীলন
খাতা-কলম নিয়ে বসুন; প্রথমে নিজে করুন, তারপর উত্তর মেলান।
-
Test নকশা — পাসওয়ার্ড: বাজারঘরের (কাল্পনিক) নিয়ম: “পাসওয়ার্ড ৮ থেকে ৬৪ অক্ষরের; অন্তত একটি ইংরেজি অক্ষর (A–Z বা a–z) আর অন্তত একটি অঙ্ক (0–9) থাকতে হবে; ফাঁকা জায়গা চলবে না।” Valid আর invalid দল লিখুন, প্রতিটির একটি প্রতিনিধি দিন (প্রতিটি invalid প্রতিনিধি যেন একটিই শর্ত ভাঙে), আর requirement-এ কোন প্রশ্ন রয়ে গেল বলুন।
শর্ত চারটি: দৈর্ঘ্য ৮–৬৪, অক্ষর আছে, অঙ্ক আছে, ফাঁকা নেই। দল ৭টি (প্রতিনিধিগুলো কোডে যাচাই করা):
ID দল প্রতিনিধি দৈর্ঘ্য V1 সব শর্ত মানা bazar20269 X1 খালি ""0 X2 ১–৭ অক্ষর ab124 X3 ৬৫+ অক্ষর a1× 3366 X4 অঙ্ক নেই abcdefgh8 X5 অক্ষর নেই 123456788 X6 ফাঁকা আছে abcd 12349 খালি পাসওয়ার্ড আসলে দৈর্ঘ্য, অক্ষর আর অঙ্ক — তিনটি শর্তই ভাঙে; তবু এটি প্রায় সব app-এ আলাদা আচরণ পায়, তাই আলাদা দল। খোলা প্রশ্ন: বাংলা অক্ষর (“বাজার2026”) কি “অক্ষর” হিসেবে গণ্য? বিশেষ চিহ্ন (
@,#) চলবে? শুরু বা শেষের ফাঁকা কি কেটে ফেলা হবে, না প্রত্যাখ্যান? দৈর্ঘ্য গোনা হবে অক্ষরে না byte-এ? সীমার মান (৭, ৮, ৬৪, ৬৫) পর্ব ০৮-এ যোগ হবে। -
Failure পড়ুন: ডেলিভারি চার্জের নিয়ম: ঢাকার ভেতরে ৬০, বাইরে ১২০; অর্ডার ২০০০ বা বেশি হলে ঢাকার ভেতরে ফ্রি। চারটি valid দলের মিশ্রণের প্রতিনিধি: D1 (Dhaka, 1500, প্রত্যাশা 60), D2 (Dhaka, 2500, 0), D3 (outside, 1500, 120), D4 (outside, 2500, 120). একটি implementation-এ test চালিয়ে এই আসল আউটপুট এলো। কোন দলে ভুল, আর কোডের ভুলটি কী হতে পারে? শুধু D1 আর D3 থাকলে কী হতো?
test_partitions (__main__.DeliveryEP.test_partitions) ... test_partitions (__main__.DeliveryEP.test_partitions) [D4] ... FAIL ====================================================================== FAIL: test_partitions (__main__.DeliveryEP.test_partitions) [D4] ---------------------------------------------------------------------- Traceback (most recent call last): File "delivery_test.py", line 15, in test_partitions self.assertEqual(delivery_charge(district, amount), expected) ~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ AssertionError: 0 != 120 ---------------------------------------------------------------------- Ran 1 test in 0.001s FAILED (failures=1)ব্যর্থ শুধু D4: ঢাকার বাইরে, ২৫০০ টাকা। Function দিয়েছে ০, requirement চায় ১২০. অর্থাৎ ফ্রি ডেলিভারি ঢাকার বাইরেও দেওয়া হচ্ছে। সম্ভাব্য কোড: আগে
if amount >= 2000: return 0, তারপর জেলা দেখা — জেলার শর্তটি ফ্রি-র নিয়মে জোড়া হয়নি। (আউটপুটটি সত্যিই এমন একটি implementation চালিয়ে পাওয়া; file-এর path নিরপেক্ষ নামে বদলানো।)শুধু D1 আর D3 থাকলে মোটের “২০০০+” দলটিই বাদ পড়ত, আর দুটি test পাস করে ভুলটি লুকিয়ে থাকত। Each-choice-এর দুটি test-এও ভাগ্যের খেলা: D1 আর D4 নিলে সব input দল ছোঁয়া হয়, D4 ভুলটি ধরে, কিন্তু output “০” (ফ্রি) কখনো দেখা হয় না; D2 আর D3 নিলেও সব input দল ছোঁয়া হয়, অথচ ভুলটি ধরা পড়ে না (D2-তে ০, D3-তে ১২০ — দুটিই ঠিক)। যে ভুল দুটি ঘরের মিলনে থাকে, তা ধরতে মিশ্রণ নিয়ে ভাবতে হয় — পর্ব ০৯-এর decision table ঠিক এই কাজের।
-
Test টেবিলের ভুল খুঁজুন: একজন সহকর্মী ফোন নম্বরের (১১ অঙ্ক, শুরু 01, তৃতীয় অঙ্ক 3–9; §৩-এর সাতটি দল) জন্য এই টেবিল জমা দিয়ে লিখেছেন “সব invalid দল ঢাকা, partition coverage ১০০%”. টেবিলে কী কী ভুল, আর আসল coverage কত?
ID Input লেখা দল Expected T1 01712345678valid গ্রহণ T2 0171234567খুব ছোট প্রত্যাখ্যান T3 0171234567aখুব ছোট প্রত্যাখ্যান T4 01012345তৃতীয় অঙ্ক 0–2 প্রত্যাখ্যান T5 ""খালি প্রত্যাখ্যান - T3-এর দল ভুল লেখা:
0171234567a১১ অক্ষরের, ছোট নয়; এটি “অঙ্ক ছাড়া চিহ্ন” দলের (X4). দল ভুল লিখলে coverage-এর হিসাবও ভুল হয়। - T4 দুটি শর্ত ভাঙে: ৮ অঙ্ক (দৈর্ঘ্য) আর তৃতীয় অঙ্ক 0. Validator দৈর্ঘ্য দেখেই প্রত্যাখ্যান করলে তৃতীয় অঙ্কের যাচাই আছে কি না, জানা যাবে না — masking. সঠিক প্রতিনিধি যেমন
01112345678. - দুটি দল পুরো বাদ: X3 (১২+ অঙ্ক) আর X5 (শুরু 01 নয়)। উপরের code block-এর
>=ভুলটি X3 ছাড়া ধরা পড়ে না।
আসল coverage: ছোঁয়া দল V1, X1, X2, X4, আর T4-এর মাধ্যমে X6 — ৫টি, অর্থাৎ ৫ ÷ ৭ = ৭১.৪%. কড়াভাবে দেখলে T4-এ X6 masking-এ ঢাকা, তাই তাকে না গুনলে ৪ ÷ ৭ = ৫৭.১%. দুটির কোনোটিই ১০০% নয়।
- T3-এর দল ভুল লেখা:
-
হিসাব — পরীক্ষার ধাঁচে: বাজারঘরের অর্ডার-ফর্মে তিনটি ঘর: পণ্যের পরিমাণ (১–১০ পূর্ণসংখ্যা valid; invalid: ০ বা কম, ১০-এর বেশি, ভগ্নাংশ), পেমেন্ট (cash, mobile-wallet, card — প্রতিটি আলাদা আচরণ; invalid: কিছু বাছাই হয়নি), ডেলিভারি সময় (সকাল, সন্ধ্যা; invalid: বাছাই হয়নি)। (ক) মোট দল কয়টি? (খ) Each-choice আর একবারে একটি invalid নিয়মে সর্বনিম্ন কয়টি test? (গ) Base-choice-এ কয়টি? (ঘ) শুধু valid মিশ্রণ কয়টি, আর সব দলের সব মিশ্রণ কয়টি? (ঙ) তিনটি test — (৫, cash, সকাল), (৭, card, সন্ধ্যা), (০, cash, সকাল) — কত partition coverage দেয়?
দল: পরিমাণে ১ valid + ৩ invalid = ৪; পেমেন্টে ৩ + ১ = ৪; সময়ে ২ + ১ = ৩. (সব সংখ্যা কোডে যাচাই করা।)
- (ক) মোট দল ৪ + ৪ + ৩ = ১১.
- (খ) Valid test = সবচেয়ে বেশি valid দল (পেমেন্টের ৩) = ৩; invalid test = ৩ + ১ + ১ = ৫; মোট ৮.
- (গ) Base-choice = ১ + (৪−১) + (৪−১) + (৩−১) = ৯.
- (ঘ) Valid মিশ্রণ ১ × ৩ × ২ = ৬; সব দলের মিশ্রণ ৪ × ৪ × ৩ = ৪৮.
- (ঙ) ছোঁয়া দল: পরিমাণ valid, পরিমাণ “০ বা কম”, cash, card, সকাল, সন্ধ্যা = ৬টি। Coverage ৬ ÷ ১১ = ৫৪.৫%. Mobile-wallet, দুটি invalid পরিমাণ-দল আর দুটি “বাছাই হয়নি” দল বাকি।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমEquivalence partitioning-এর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Test basis থেকে input আর output চিহ্নিত করা, নিয়মকে আলাদা শর্তে ভাঙা
- Valid partition লেখা — যেখানে requirement আলাদা আচরণ বলে
- প্রতিটি শর্তের জন্য invalid partition লেখা
- Overlap আর ফাঁক যাচাই করা
- প্রতিটি দলের প্রতিনিধি আর requirement থেকে expected result ঠিক করা
- Valid দল মিলিয়ে আর প্রতিটি invalid দল আলাদা করে test সাজানো
একটি ঘরে বয়স লিখতে হয়; নিয়ম: “18 থেকে 60 পূর্ণসংখ্যা গ্রহণযোগ্য।” শুধু সংখ্যার মান বিবেচনা করলে (অক্ষর বা ভগ্নাংশ বাদে) সর্বনিম্ন কয়টি equivalence partition?
- ১টি
- ৩টি
- ৪টি
- ৬টি
একটি checkout form-এর test-এ ফোন নম্বর আর মোট টাকা — দুটিতেই একসঙ্গে invalid মান দেওয়া হলো। এই নকশার মূল সমস্যা কী?
- Test-এর সংখ্যা অকারণে বেড়ে যায়
- Invalid মান দিয়ে test করাই উচিত নয়
- একটি ভুল আরেকটির যাচাইকে আড়াল করতে পারে (error masking)
- Partition coverage শূন্য হয়ে যায়
একটি ঘরের জন্য ৮টি equivalence partition চিহ্নিত হয়েছে। Test suite এর ৬টি দলের মান ব্যবহার করে। Equivalence partition coverage কত?
- ৭৫%
- ৬০%
- ১০০%, কারণ প্রতিটি test সফল
- ২৫%
তিনটি input ঘরে valid partition যথাক্রমে ৪, ৩ আর ২টি (কোনো invalid দল নেই)। Each-choice coverage পেতে সর্বনিম্ন কয়টি test লাগে?
- ২৪টি
- ৯টি
- ২টি
- ৪টি
একটি requirement-এর জন্য tester দল লিখেছেন: “0–1000: ছাড় নেই” আর “1000–3000: ১০% ছাড়”. এই দুটি দলের প্রধান ত্রুটি কী?
- দুটিই invalid দল হওয়া উচিত
- মান 1000 দুটি দলেই পড়ে — দলগুলো overlap করছে
- দল দুটি খালি
- দল খুব বেশি, একটিই যথেষ্ট
একজন tester validator-এর কোড পড়ে দেখলেন, তৃতীয় অঙ্ক “23456789”-এর মধ্যে হলে নম্বর গৃহীত হয়, আর সেই অনুযায়ী partition বানালেন। Requirement বলে তৃতীয় অঙ্ক 3–9. এতে কী ঝুঁকি?
- কোনো ঝুঁকি নেই, কোড থেকে দল বানানো দ্রুত
- Test-এর সংখ্যা অনেক বেড়ে যাবে
- কোডের ভুল দলে ঢুকে যায়, আর test ভুলসহ পাস করে
- Partition coverage সবসময় শূন্য দেখাবে
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- EP-র অনুমান: দলের ভেতরে একই আচরণ, তাই প্রতিটি দল থেকে একটি প্রতিনিধি। দল আসে requirement থেকে, কোড থেকে নয়।
- ভালো দল খালি নয়, overlap করে না, মিলে সব ঢাকে; valid আর invalid দুই রকমই লিখুন, প্রতিটি শর্তের জন্য আলাদা invalid.
- প্রতিনিধি নিন মাঝামাঝি থেকে; expected result হাতে requirement থেকে; সীমার মান পরের পর্বে।
- একবারে একটি invalid, বাকি ঘর valid — নইলে error masking. Each-choice = max(vi) + Σxi, base-choice = 1 + Σ(দল − 1).
- Partition coverage = ছোঁয়া দল ÷ চিহ্নিত দল; ১০০% মানে শুধু চেনা দল ঢাকা — লুকানো দল (বাংলা অঙ্ক!) আর output দলের কথা ভাবুন।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ০৮ · Boundary value analysis — দুই-মান আর তিন-মান পদ্ধতিপরবর্তী পর্বসীমার ঠিক আশেপাশে ভুল লুকিয়ে থাকে, তা ধরার কৌশল।
- সফটওয়্যার টেস্টিং ও QA · কোর্স হোম৮২টি পর্ব১৪টি মডিউলের পুরো রোডম্যাপ।
- পর্ব ০২ · Testing কী — error, defect, failure আর verification বনাম validationফিরে দেখুনকেন সব input test করা অসম্ভব — হিসাবসহ।
- সফটওয়্যার ইঞ্জিনিয়ারিং ও Git · পর্ব ৪৭পাশের ট্র্যাকTest নকশার সব কৌশলের এক পর্বে সংক্ষিপ্ত পরিচয়।
- ডিসক্রিট ম্যাথ · পর্ব ৩১গভীরে যানযোগ আর গুণের নিয়ম — মিশ্রণ গোনার গণিত।