এই পর্বে যা শিখবেন
- যেকোনো ক্রমযুক্ত input থেকে সীমার মান, ২-মান আর ৩-মান test set হাতে আর কোডে বের করা
- কোন ধরনের off-by-one ভুল কোন set ধরে, mutant বসিয়ে নিজে মেপে দেখা
- BVA-র test case টেবিলকে আসল unittest-এ রূপ দেওয়া আর fail-এর বার্তা পড়া
- দৈর্ঘ্য, গণনা, তারিখ, সময় অঞ্চল আর দশমিকের সীমা চেনা; লুকানো সীমা খোঁজা
- একাধিক input-এ robustness আর worst-case গণনা, আর BVA coverage-এর হিসাব
১ · সীমায় কেন ভুল জমে — off-by-one আর বেড়ার খুঁটি
বাসের কন্ডাক্টর বলেন, “তিন বছরের কম বয়সী শিশুর টিকিট লাগে না।” ঠিক তিন বছর বয়সী শিশুর টিকিট লাগবে কি? মোবাইল রিচার্জের অ্যাপ বলে, “২০ থেকে ১০০০ টাকা পর্যন্ত রিচার্জ করা যাবে।” ১০০০ টাকা দিলে চলবে, ১০০১ দিলে আটকাবে কি? মাঝের মানগুলো নিয়ে কেউ তর্ক করে না: ৫০০ টাকা যে চলবে, সবাই জানেন। তর্ক, ভুল আর অভিযোগ জমে কিনারায়।
Developer-এর বেলায়ও তাই। নিয়ম “১০০০ টাকার বেশি” হলে কোডে > লিখতে হয়; ক্লান্ত চোখে >= চলে আসে। লুপ ০ থেকে শুরু না ১ থেকে, শেষ উপাদান বাদ পড়ল কি না, এমন এক ঘরের ভুলকে বলে off-by-one error. এর পুরোনো ডাকনাম “বেড়ার খুঁটির ভুল” (fencepost error): ১০ মিটার বেড়ায় ১ মিটার পরপর খুঁটি লাগলে খুঁটি ১০টি নয়, ১১টি। মাথায় এক হিসাব, আসলে আরেক।
পর্ব ০৭ (Equivalence partitioning — অসংখ্য input থেকে অল্প কয়েকটি test)-এ শিখেছেন input-কে এমন দলে ভাগ করতে, যার ভেতরের সব মানের সাথে software একই আচরণ করার কথা। প্রতিটি দল থেকে একটি প্রতিনিধি নিলে কম test-এ সব আচরণ ঢাকা যায়। কিন্তু প্রতিনিধি সাধারণত দলের মাঝখান থেকে আসে, যেমন ৫০০ বা ২০০০ টাকা। ওপরের >= ভুলটি শুধু ঠিক ১০০০ টাকায় ধরা পড়ে, আর ১০০০ কোনো দলের মাঝখানে নেই; এটি “ছাড় নেই” দলের একেবারে শেষ মান। BVA সেই ফাঁক পূরণ করে।
দর্জির দোকানে মাপ নেওয়ার কথা ভাবুন। গায়ের মাঝখানের মাপ নিয়ে কেউ ভুল করে না; ভুল হয় কাঁধের শেষ প্রান্তে, হাতার শেষে, কলারের ঘেরে। ভালো দর্জি তাই প্রান্তগুলো দুবার মাপেন। BVA হলো test-এর প্রান্ত মাপা: যেখানে নিয়ম বদলায়, ঠিক সেখানে আর তার এক ঘর এদিক-ওদিক।
Glenford Myers-এর The Art of Software Testing (১৯৭৯) equivalence partitioning-এর পরেই boundary value analysis ব্যাখ্যা করে, আর মন্তব্য করে যে সীমার অবস্থা পরীক্ষা করা test, না করা test-এর চেয়ে বেশি ফল দেয়। পরে Boris Beizer (Software Testing Techniques, দ্বিতীয় সংস্করণ ১৯৯০) আর Paul Jorgensen (Software Testing: A Craftsman’s Approach, প্রথম সংস্করণ ১৯৯৫) কৌশলটিকে গুছিয়ে রূপভেদ দেন। আজকের প্রচলিত সংজ্ঞা পাওয়া যায় ISTQB-এর Foundation syllabus (সংস্করণ ৪.০, ২০২৩) আর ISO/IEC/IEEE 29119-4 মানে।
সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৪৭-এ on point, off point আর একটি নম্বরের ঘরের ২-মান ও ৩-মান হিসাব সংক্ষেপে দেখেছেন। এখানে আরও গভীরে যাব: নির্ভুল গোনার নিয়ম, mutant দিয়ে দুই পদ্ধতির তুলনা, দৈর্ঘ্য-তারিখ-দশমিকের সীমা, একাধিক input আর ফাঁদ। সব উদাহরণ বাজারঘরের পরিচিত নিয়ম দিয়ে:
Coupon: অর্ডার ১০০০ টাকার বেশি হলে ১০% ছাড়, সর্বোচ্চ ৩০০ টাকা; ছাড় পূর্ণ টাকায়, ভগ্নাংশ বাদ। Delivery charge: ঢাকার ভেতরে ৬০ টাকা, বাইরে ১২০ টাকা; ঢাকার ভেতরে অর্ডার ২০০০ টাকা বা বেশি হলে ফ্রি। Password: ৮ থেকে ৬৪ অক্ষর। Phone number: ১১ অঙ্ক, শুরু 01, তৃতীয় অঙ্ক 3 থেকে 9 (কাল্পনিক নিয়ম)। এই পর্বে অর্ডারের মোট টাকা পূর্ণ সংখ্যা ধরা হলো; পয়সার কথা §৬-এ।
২ · ISTQB-এর ভাষায় BVA — সীমার মান, দুই-মান আর তিন-মান
BVA দাঁড়িয়ে আছে equivalence partitioning-এর ওপর। শর্ত একটাই: partition-গুলো ক্রমযুক্ত হতে হবে, অর্থাৎ মানগুলোকে ছোট থেকে বড় সাজানো যায়, আর একটি partition-এর দুটি মানের মাঝের সব মানও সেই partition-এ পড়ে। টাকা, বয়স, দৈর্ঘ্য, তারিখ ক্রমযুক্ত। জেলার নাম বা payment method (cash, mobile-wallet, card) ক্রমযুক্ত নয়; সেখানে “সীমা” বলে কিছু নেই, তাই BVA খাটে না।
ISTQB-এর সংজ্ঞা, আমাদের ভাষায়:
- সীমার মান (boundary value): একটি partition-এর সবচেয়ে ছোট আর সবচেয়ে বড় মান। অবৈধ partition-ও partition, তাই তারও সীমা আছে, যদি দিকটি খোলা না হয়।
- ২-মান BVA: প্রতিটি সীমার মানের জন্য দুটি coverage item: মানটি নিজে, আর পাশের partition-এর নিকটতম মান।
- ৩-মান BVA: প্রতিটি সীমার মানের জন্য তিনটি: মানটি নিজে আর তার দুই পাশের প্রতিবেশী।
- BVA coverage: চালানো coverage item ÷ চিহ্নিত মোট coverage item, শতাংশে।
“নিকটতম” মানে ক্ষুদ্রতম ধাপ। পূর্ণ টাকায় ধাপ ১; পয়সাসহ টাকায় ০.০১; দৈর্ঘ্যে একটি অক্ষর; সময়ে নিয়ম যত সূক্ষ্ম, যেমন এক সেকেন্ড। ধাপ না জেনে BVA শুরু করা যায় না, তাই requirement থেকে প্রথমে input-এর ধরন জেনে নিন।
কাজের ধারা — ছয় ধাপে BVA
- Requirement পড়ে input চিহ্নিত করুন, তার ধরন আর ক্ষুদ্রতম ধাপ লিখুন।
- বৈধ আর অবৈধ partition বানান (পর্ব ০৭-এর পদ্ধতিতে), ক্রম অনুযায়ী সাজিয়ে।
- প্রতিটি partition-এর সর্বনিম্ন আর সর্বোচ্চ মান লিখুন: এগুলোই সীমার মান।
- ঝুঁকি দেখে ২-মান না ৩-মান ঠিক করুন, coverage item-এর তালিকা বানান, পুনরাবৃত্তি বাদ দিন।
- প্রতিটি মানের expected result requirement থেকে লিখুন, কোড থেকে নয়। অস্পষ্টতা পেলে এখনই প্রশ্ন তুলুন।
- Test চালান, coverage % হিসাব করুন, ফলাফল লিখে রাখুন।
Coupon-এর সংখ্যারেখা — partition, সীমা আর প্রতিবেশী
Order total number line (not to scale): partitions, 2-value pairs and a zoom on the 1000/1001 boundary
৩ · Coupon-এর সীমা ধাপে ধাপে, আর কোডে boundary set
এবার ছয় ধাপের পদ্ধতি coupon নিয়মে প্রয়োগ করি। শেষ ধাপটি খেয়াল করুন: requirement-এ লেখা সীমা আর কোডের আচরণ যেখানে বদলায়, দুটি সবসময় এক জায়গায় থাকে না। “পরে” চাপুন:
| ধাপ | |
| পাওয়া গেল | |
| test-এর সংখ্যা |
- নিয়ম পড়া। Input একটি: মোট টাকা, পূর্ণ সংখ্যা, তাই ক্ষুদ্রতম ধাপ ১ টাকা। “বেশি” শব্দটি গুরুত্বপূর্ণ: ঠিক ১০০০ টাকায় ছাড় নেই।
- Partition. চারটি ক্রমযুক্ত দল: শূন্য বা কম (অবৈধ), ১–১০০০ (ছাড় শূন্য), ১০০১–৩০০০ (দশ ভাগের এক ভাগ), ৩০০১ থেকে ওপরে (৩০০ টাকা)। প্রথম আর শেষ দলের একটি দিক খোলা।
- সীমার মান। প্রতিটি দলের সর্বনিম্ন আর সর্বোচ্চ: অবৈধ দলের সর্বোচ্চ 0, তারপর 1 ও 1000, 1001 ও 3000, আর 3001. খোলা দিকের কোনো সীমা নেই। মোট ৬টি।
- ২-মান BVA. প্রতিটি সীমার মান আর পাশের দলের নিকটতম মান। 1000-এর পাশের দলের নিকটতম মান 1001, যা নিজেই একটি সীমার মান। তাই set-এ নতুন কিছু যোগ হয় না: ৬টি test.
- ৩-মান BVA. প্রতিটি সীমার মানের দুই প্রতিবেশী: 0-এর জন্য −1, 1-এর জন্য 2, 1000-এর জন্য 999, 1001-এর জন্য 1002, এভাবে। পুনরাবৃত্তি বাদে ১২টি test.
- লুকানো সীমা। ছাড় ভগ্নাংশ বাদ দিয়ে হিসাব হয়, তাই 3000 থেকে 3009 পর্যন্ত cap থাকুক বা না থাকুক ফল 300. Cap সত্যিই কাজ শুরু করে 3010-এ, যেখানে cap ছাড়া ছাড় হতো 301. কোনো BVA set-এ 3010 নেই; partition-এর ভেতরের প্রতিনিধি 5000 এই অংশ ঢাকে। §৪-এ এর ফল দেখবেন।
একই হিসাব কোডে করলে নতুন নিয়মে আবার ব্যবহার করা যায়, আর গোনায় ভুল হয় না। নিচের ফাংশন partition-এর তালিকা নেয় (None মানে খোলা দিক) আর ISTQB-এর সংজ্ঞা হুবহু মেনে তিনটি তালিকা ছাপে। “চালান” চাপুন; প্রথমবার ব্রাউজারে Pyodide (ব্রাউজারের Python) নামতে কয়েক সেকেন্ড লাগে।
def boundary_sets(parts, lowest=None, highest=None):
"""parts: ordered, touching partitions (lo, hi); None = open end."""
bounds = sorted({v for p in parts for v in p if v is not None})
two = set()
for i, (lo, hi) in enumerate(parts):
if lo is not None: # min + nearest value below
two.add(lo)
if i > 0: two.add(lo - 1)
if hi is not None: # max + nearest value above
two.add(hi)
if i < len(parts) - 1: two.add(hi + 1)
ok = lambda v: ((lowest is None or v >= lowest) and
(highest is None or v <= highest))
three = {v + d for v in bounds for d in (-1, 0, 1) if ok(v + d)}
return bounds, sorted(two), sorted(three)
RULES = { # name: (partitions, lowest, highest)
"coupon total": ([(None, 0), (1, 1000), (1001, 3000), (3001, None)],
None, None),
"password length": ([(0, 7), (8, 64), (65, None)], 0, None),
"phone 3rd digit": ([(0, 2), (3, 9)], 0, 9),
}
for name, (parts, low, high) in RULES.items():
b, two, three = boundary_sets(parts, low, high)
print(name)
print(f" boundaries ({len(b)}): {b}")
print(f" 2-value ({len(two)}): {two}")
print(f" 3-value ({len(three)}): {three}")আসল আউটপুট (ব্রাউজারের Python):
coupon total
boundaries (6): [0, 1, 1000, 1001, 3000, 3001]
2-value (6): [0, 1, 1000, 1001, 3000, 3001]
3-value (12): [-1, 0, 1, 2, 999, 1000, 1001, 1002, 2999, 3000, 3001, 3002]
password length
boundaries (5): [0, 7, 8, 64, 65]
2-value (5): [0, 7, 8, 64, 65]
3-value (10): [0, 1, 6, 7, 8, 9, 63, 64, 65, 66]
phone 3rd digit
boundaries (4): [0, 2, 3, 9]
2-value (4): [0, 2, 3, 9]
3-value (7): [0, 1, 2, 3, 4, 8, 9]
তিনটি নিয়মেই ২-মান set আর সীমার মানের তালিকা হুবহু এক। কারণ partition-গুলো গায়ে গায়ে লাগানো: একটি দলের সর্বোচ্চ মানের “পাশের দলের নিকটতম মান” আসলে পরের দলের সর্বনিম্ন মান, যা আগেই তালিকায় আছে। ফাঁক থাকলে (যেমন দুটি নিয়মের মাঝে কোনো মান কোনো দলেই নেই) তা হতো না, আর সেই ফাঁক নিজেই requirement-এর একটি defect. দৈর্ঘ্যে lowest=0: −1 অক্ষরের password হয় না, তাই 0-এর প্রতিবেশী শুধু 1. তৃতীয় অঙ্কে 9-এর ওপরে কোনো অঙ্ক নেই, তাই 9-এর প্রতিবেশী শুধু 8. খেয়াল করুন, এই হিসাবে অবৈধ দলের সীমাও (coupon-এ 0) গোনা হয়েছে, যা ISTQB-এর সংজ্ঞার আক্ষরিক রূপ। কিছু বই শুধু বৈধ দলের কিনারা ধরে, তখন coupon-এ ৩-মানের −1 বাদ পড়ে ১১টি হয়। পরীক্ষায় প্রশ্ন কোন রীতি চাইছে খেয়াল করুন।
৪ · > বনাম >= — mutant দিয়ে কোন set কী ধরে
কোন test set ভালো, তা মাপার একটি সৎ উপায়: কোডে ইচ্ছা করে ছোট একটি ভুল বসানো, তারপর দেখা set-টি ভুলটি ধরে কি না। এমন বদলানো কোডকে বলে mutant; কোনো test fail করলে mutant-টি “মারা গেল” (killed). পুরো কৌশলটির নাম mutation testing, যা পর্ব ৫৯-এ আসল tool দিয়ে দেখবেন। এখানে শুধু ধারণাটি দিয়ে BVA-র দুই রূপ মাপব। প্রথমে সবচেয়ে চেনা ভুলটি: total > 1000-এর জায়গায় total >= 1000.
1if total > 1000: # আসল2if total >= 1000: # mutant3 ছাড় = min(total // 10, 300)4else: ছাড় = 0
| input | |
| আসল | |
| mutant |
- EP-র প্রতিনিধি 1500. দুই কোডেই শর্ত সত্য, ছাড় ১৫০. ফল মিলে গেল, তাই এই test mutant-টিকে আলাদা করতে পারল না।
- আরেকটি ভেতরের মান 2000. আবার দুই কোডেই ২০০. দলের মাঝখানের যত মানই নিন, এই ভুল ধরা পড়বে না।
- সীমার ঠিক ওপরের মান 1001. আসলে
1001 > 1000সত্য, mutant-এ1001 >= 1000-ও সত্য। দুই কোডেই ছাড় ১০০. সীমার মান হলেও এটি ভুল দিকের মান। - নিয়মে লেখা সংখ্যাটি নিজে, 1000. আসলে
1000 > 1000মিথ্যা, ছাড় শূন্য; mutant-এ1000 >= 1000সত্য, ছাড় ১০০. ফল আলাদা: mutant killed. নিয়মে লেখা সংখ্যাটিকে বলা হয় on point, আর অন্য পাশের নিকটতম 1001 হলো off point. - সারাংশ। চারটি test-এর মধ্যে শুধু একটি ভুলটি ধরল, আর সেটি সীমার ঠিক ওপরে বসা মান। ২-মান আর ৩-মান দুই set-এই 1000 আছে, তাই দুটিই এই mutant ধরে। শুধু EP-র প্রতিনিধি দিয়ে test করলে ধরা পড়ত না।
এবার ছয়টি ভিন্ন mutant একসাথে। কোডটি আসল coupon ফাংশনের লেখা (source) নেয়, প্রতিবার একটি ছোট লেখা বদলে নতুন ফাংশন বানায় (আসল mutation tool-ও মূলত এটাই করে), তারপর পাঁচটি test set চালিয়ে দেখে কোন set কোন mutant মারে। ছকের প্রতিটি ঘরে থাকে প্রথম যে input ভুলটি ধরল, আর - মানে mutant বেঁচে গেল।
SRC = """
def coupon(t):
if t < 1: raise ValueError("total must be >= 1")
if t <= 1000: return 0
return min(t // 10, 300)
"""
MUTATIONS = [("t < 1:", "t < 0:"), ("t <= 1000", "t < 1000"),
("t <= 1000", "t <= 1001"), ("t <= 1000", "t == 1000"),
("300)", "301)"), ("t // 10", "round(t / 10)")]
def load(src): # build a function from source
ns = {}
exec(src, ns)
return ns["coupon"]
def run(f, t): # a ValueError is an outcome too
try: return f(t)
except ValueError: return "error"
good = load(SRC)
SETS = {"EP": [-50, 500, 2000, 5000],
"2v": [0, 1, 1000, 1001, 3000, 3001],
"3v": [-1, 0, 1, 2, 999, 1000, 1001, 1002, 2999, 3000, 3001, 3002]}
SETS["2v+EP"] = SETS["2v"] + SETS["EP"]
SETS["3v+EP"] = SETS["3v"] + SETS["EP"]
killed = dict.fromkeys(SETS, 0)
print(f"{'mutant':<16}" + "".join(f"{s:>7}" for s in SETS))
for i, (old, new) in enumerate(MUTATIONS, 1):
bad, cells = load(SRC.replace(old, new, 1)), []
for name, tests in SETS.items():
hit = [t for t in tests if run(bad, t) != run(good, t)]
killed[name] += bool(hit)
cells.append(str(hit[0]) if hit else "-") # first killer
print(f"M{i} {new:<13}" + "".join(f"{c:>7}" for c in cells))
print(f"{'killed (of 6)':<16}" + "".join(f"{k:>7}" for k in killed.values()))আসল আউটপুট (ব্রাউজারের Python):
mutant EP 2v 3v 2v+EP 3v+EP
M1 t < 0: - 0 0 0 0
M2 t < 1000 - 1000 1000 1000 1000
M3 t <= 1001 - 1001 1001 1001 1001
M4 t == 1000 500 - 999 500 999
M5 301) 5000 - - 5000 5000
M6 round(t / 10) - - 2999 - 2999
killed (of 6) 2 3 5 5 6
আসল কোডে শর্তটি উল্টো দিক থেকে লেখা (t <= 1000 হলে ছাড় শূন্য), তাই M2 হলো ওপরের stepper-এর ভুলটিই। প্রতিটি সারি পড়ুন:
- M1–M3: সীমা এক ঘর সরানো (অবৈধ সীমা 0-তে, ছাড়ের সীমা 999 বা 1001-এ)। ২-মান আর ৩-মান দুটিই ধরে; EP-র প্রতিনিধি কোনোটিই ধরে না। BVA-র জন্মই এই কাজে।
- M4:
<=-এর জায়গায়==. এখন শুধু ঠিক 1000-এ ছাড় শূন্য, 999-এ ছাড় 99. ২-মানের 1000 আর 1001 দুটিতেই ফল ঠিক আসে, তাই ২-মান ফসকায়; ৩-মানের 999 ধরে। ISTQB-এর syllabus ঠিক এই ধাঁচের উদাহরণ দিয়ে দেখায় ৩-মান কেন বেশি কঠোর। এখানে EP-র 500-ও ধরে, কারণ ভুলটি পুরো দলের আচরণ বদলে দিয়েছে। - M5: cap 301. কোনো BVA set ধরে না, কারণ §৩-এর লুকানো সীমা: cap-এর প্রভাব শুরু 3010-এ, আর কোনো set-এ 3010 বা তার বেশি মান নেই। ধরে শুধু EP-র 5000. এজন্যই BVA একা নয়, EP-র সাথে।
- M6: ভগ্নাংশ বাদের বদলে কাছের পূর্ণ সংখ্যায় গোল করা। 2999-এ আসল ছাড় 299, mutant-এ 299.9 গোল হয়ে 300. শুধু ৩-মানের 2999 ধরে।
সারাংশ: EP একা ২টি, ২-মান ৩টি, ৩-মান ৫টি, ২-মান+EP ৫টি, ৩-মান+EP ৬টির ৬টিই। এই একটি উদাহরণে সংখ্যাগুলো সাধারণ নিয়ম নয়, কিন্তু প্রবণতা চেনা: ৩-মান বেশি ধরে, আর partition-এর ভেতরের একটি মান রাখলে ভিন্ন ধরনের ভুল ধরা পড়ে।
সব mutant কি ধরা সম্ভব? না। ধরুন কেউ cap লিখল if t >= 3000: return 300, আর আরেকজন if t > 3000: return 300. 3000-এ দুটিই 300 দেয় (৩০০০-এর দশ ভাগের এক ভাগও 300), আর অন্য সব মানেও ফল এক। লেখায় আলাদা, আচরণে এক: একে বলে equivalent mutant. কোনো test একে মারতে পারবে না, আর মারার দরকারও নেই। Mutation score হিসাবের সময় এদের আলাদা করতে হয় (পর্ব ৫৯)।
৫ · Test case টেবিল থেকে আসল unittest
Manual tester-এর হাতে BVA-র ফল একটি টেবিল: প্রতিটি সারিতে একটি test case, তার input, requirement থেকে নেওয়া expected result, আর সারিটি কোন coverage item ঢাকে। ৩-মান BVA-তে coupon-এর টেবিল:
| ID | মোট টাকা | Expected ছাড় | Coverage item |
|---|---|---|---|
| BV-01 | -1 | error | 0-এর প্রতিবেশী (৩-মান) |
| BV-02 | 0 | error | অবৈধ দলের সর্বোচ্চ |
| BV-03 | 1 | 0 | বৈধ দলের সর্বনিম্ন |
| BV-04 | 2 | 0 | 1-এর প্রতিবেশী (৩-মান) |
| BV-05 | 999 | 0 | 1000-এর প্রতিবেশী (৩-মান) |
| BV-06 | 1000 | 0 | “ছাড় 0” দলের সর্বোচ্চ |
| BV-07 | 1001 | 100 | “১০%” দলের সর্বনিম্ন |
| BV-08 | 1002 | 100 | 1001-এর প্রতিবেশী (৩-মান) |
| BV-09 | 2999 | 299 | 3000-এর প্রতিবেশী (৩-মান) |
| BV-10 | 3000 | 300 | “১০%” দলের সর্বোচ্চ |
| BV-11 | 3001 | 300 | “cap” দলের সর্বনিম্ন |
| BV-12 | 3002 | 300 | 3001-এর প্রতিবেশী (৩-মান) |
Automation engineer এই টেবিলকেই কোডে বসান। টেবিলটি একটি তালিকা, আর একটি test method তালিকার প্রতিটি সারি চালায়। self.subTest প্রতিটি সারিকে আলাদা subtest হিসেবে চালায়, তাই একটি সারি fail করলেও বাকিগুলো চলতে থাকে আর বার্তায় সারির ID আসে। নিচের ফাংশনে একটি ভুল ইচ্ছা করে বসানো আছে; চালানোর আগে টেবিল দেখে অনুমান করুন কোন সারি লাল হবে।
import sys, unittest
def coupon_discount(total):
"""Bazarghar: total over 1000 -> 10% off (whole taka), max 300."""
if total < 1:
raise ValueError("total must be at least 1")
if total >= 1000: # seeded defect: rule says "over"
return min(total // 10, 300)
return 0
ERR = ValueError
CASES = [(-1, ERR), (0, ERR), (1, 0), (2, 0), (999, 0), (1000, 0),
(1001, 100), (1002, 100), (2999, 299), (3000, 300),
(3001, 300), (3002, 300)] # 3-value BVA table
class CouponBVA(unittest.TestCase):
def test_boundaries(self):
for n, (total, expected) in enumerate(CASES, 1):
with self.subTest(f"BV-{n:02}", total=total):
if expected is ERR:
with self.assertRaises(ERR):
coupon_discount(total)
else:
self.assertEqual(coupon_discount(total), expected)
def test_ep_representative(self): # one value deep inside
self.assertEqual(coupon_discount(5000), 300)
suite = unittest.TestLoader().loadTestsFromTestCase(CouponBVA)
unittest.TextTestRunner(stream=sys.stdout, verbosity=2).run(suite)আসল আউটপুট (ব্রাউজারের Python, traceback-এর মাঝের লাইন ছাঁটা):
test_boundaries (__main__.CouponBVA.test_boundaries) ...
test_boundaries (__main__.CouponBVA.test_boundaries) [BV-06] (total=1000) ... FAIL
test_ep_representative (__main__.CouponBVA.test_ep_representative) ... ok
======================================================================
FAIL: test_boundaries (__main__.CouponBVA.test_boundaries) [BV-06] (total=1000)
----------------------------------------------------------------------
Traceback (most recent call last):
…
AssertionError: 100 != 0
----------------------------------------------------------------------
Ran 2 tests in 0.001s
FAILED (failures=1)
বারোটি সারির মধ্যে শুধু BV-06 লাল: input 1000, কোড দিল 100 (প্রথম মান, actual), টেবিল চায় 0 (দ্বিতীয় মান, expected). বার্তার [BV-06] (total=1000) অংশটি subTest-এর দেওয়া, তাই ব্যর্থ সারিটি সরাসরি টেবিলে খুঁজে পাওয়া যায়। Bug report-এ লিখবেন: “মোট ঠিক ১০০০ টাকায় ১০০ টাকা ছাড় দিচ্ছে; requirement অনুযায়ী ১০০০ টাকার বেশি হলে তবেই ছাড়।” EP-র test (5000) পাস করেছে, যা আবার দেখায় ভেতরের মান এই ভুল দেখতে পায় না। শেষ দুই লাইনে suite বানিয়ে TextTestRunner দিয়ে চালানো হয়েছে, ফল sys.stdout-এ; খালি unittest.main() শেষে sys.exit ডেকে block থামিয়ে দেয়।
Expected কলাম কখনো কোড চালিয়ে ভরবেন না। কেউ ভুল কোড চালিয়ে দেখল 1000-এ 100 আসে, আর টেবিলে 100 লিখে দিল: এখন test সবুজ, bug নিরাপদ। প্রতিটি expected মান requirement-এর বাক্য থেকে হাতে হিসাব করুন। Requirement নীরব হলে (যেমন 0 টাকার অর্ডারে কী হবে) সেটি product owner-কে প্রশ্ন, অনুমান নয়।
৬ · সংখ্যার বাইরের সীমা — দৈর্ঘ্য, গণনা, তারিখ আর দশমিক
BVA শুধু টাকার অঙ্কের জন্য নয়। যেখানেই ক্রম আছে, সেখানেই সীমা আছে। চারটি পরিচিত ক্ষেত্র দেখি।
String-এর দৈর্ঘ্য: password ৮ থেকে ৬৪ অক্ষর
এখানে input একটি লেখা, কিন্তু BVA চলে তার দৈর্ঘ্যের ওপর। Test data বানাতে নির্দিষ্ট দৈর্ঘ্যের লেখা লাগে, যেমন সাতটি “a”. তবে “অক্ষর” শব্দটিই এখানে একটি ফাঁদ:
| ধাপ | |
| পাওয়া গেল | |
| test-এর সংখ্যা |
- Partition. দৈর্ঘ্য ০ থেকে ৭ ছোট, ৮ থেকে ৬৪ বৈধ, ৬৫ বা বেশি লম্বা। দৈর্ঘ্য ঋণাত্মক হয় না, তাই প্রথম দলের সর্বনিম্ন মান ০, অর্থাৎ খালি ঘর।
- সীমার মান। 0 (খালি), 7 আর 8, 64 আর 65. শেষ দলের ওপরের দিক খোলা, যদি না form-এ সর্বোচ্চ ইনপুট সীমা বলা থাকে। মোট ৫টি।
- ২-মান test data. খালি লেখা, সাত, আট, চৌষট্টি আর পঁয়ষট্টি অক্ষরের লেখা: ৫টি test. প্রতিটিতে শুধু দৈর্ঘ্য বদলায়, অক্ষরের ধরন এক রাখা হয়, যাতে fail করলে কারণ পরিষ্কার থাকে।
- ৩-মান BVA. 0-এর প্রতিবেশী শুধু 1, তারপর 6, 9, 63, 66 যোগ হয়ে ১০টি test.
- লুকানো সীমা। “অক্ষর” কে গুনছে? Python-এর
lenগোনে Unicode code point. UTF-8-এ একটি বাংলা code point ৩ byte, তাই ৬৪টি বাংলা code point ১৯২ byte. Password hash করার জনপ্রিয় পদ্ধতি bcrypt শুধু প্রথম ৭২ byte দেখে; ২৪টির বেশি বাংলা code point-এর পরের অংশ তার কাছে অদৃশ্য। নতুন সীমা, নতুন test.
Byte-সীমার নিরাপত্তার দিক সাইবার সিকিউরিটি কোর্সের পর্ব ১৩-এ আছে। Tester-এর শিক্ষা: দৈর্ঘ্যের নিয়মে জিজ্ঞেস করুন, অক্ষর মানে code point, চোখে দেখা অক্ষর (grapheme cluster), না UTF-8-এর byte. “ক্ষ” চোখে একটি অক্ষর, কিন্তু code point তিনটি (ক, হসন্ত, ষ)। বাংলা লেখার এমন test পর্ব ৫৬-এ আরও আছে।
গণনা: cart-এ পণ্যের সংখ্যা
ধরুন একটি অর্ডারে ১ থেকে ২০টি পণ্য রাখা যায়। সীমার মান 0 (খালি cart), 1, 20, 21. গণনার ক্ষেত্রে 0 আর 1-এর বিশেষ গুরুত্ব আছে: খালি তালিকায় লুপ একবারও চলে না, গড় হিসাবে শূন্য দিয়ে ভাগ হয়, “প্রথম পণ্য” বলে কিছু থাকে না। লুপের test-এ তাই প্রচলিত তালিকা: শূন্যবার, একবার, দুবার, সাধারণ সংখ্যক, সর্বোচ্চ, আর সর্বোচ্চের এক বেশি। পর্ব ১৩-এর loop coverage এই তালিকারই কোডের দিক।
তারিখ আর সময়
তারিখের সীমা সবচেয়ে বেশি ঠকায়, কারণ ক্যালেন্ডার নিজেই অসমান। মাসের শেষ দিন ২৮, ২৯, ৩০ বা ৩১; ফেব্রুয়ারির ২৯ শুধু অধিবর্ষে (২০২৮ অধিবর্ষ, ২১০০ নয়); বছর বদলায় ৩১ ডিসেম্বর রাত ১১:৫৯:৫৯-এর পরে। আর “পর্যন্ত” শব্দটি অস্পষ্ট: “৩১ ডিসেম্বর পর্যন্ত coupon চলবে” মানে ৩১ তারিখসহ, নাকি ৩১ তারিখ শুরুর আগ পর্যন্ত? কোন time zone-এর ৩১ তারিখ? বাংলাদেশের সময় UTC+6, কিন্তু অনেক server সময় রাখে UTC-তে। নিচের কোডে দুটোই দেখুন।
দশমিক আর ক্ষুদ্রতম ধাপ
দাম পয়সাসহ হলে ১০০০.০০-এর নিকটতম ওপরের মান ১০০০.০১. কিন্তু কোড যদি দাম রাখে floating-point সংখ্যায়, কম্পিউটারের নিজস্ব “নিকটতম মান” আলাদা, আর যোগফল সীমার ঠিক ওপরে বা নিচে সরে যেতে পারে। নিচের block-এ চারটি পণ্যের দাম মিলে ঠিক ১০০০.০০ টাকা; দেখুন float কী বলে, আর তারপর তারিখের সীমা।
import math
from datetime import datetime, timedelta, timezone
from decimal import Decimal
# 1) Money: four items that add up to exactly 1000.00 taka
prices = ["374.67", "75.53", "131.83", "417.97"]
t = 0.0
for p in prices: # running float total, as in a cart
t += float(p)
paisa = sum(int(Decimal(p) * 100) for p in prices)
print("float total:", repr(t), "| over 1000?", t > 1000)
print("paisa total:", paisa, "| over 100000?", paisa > 100000)
print("next float above 1000.0:", math.nextafter(1000.0, math.inf))
# 2) Time: coupon valid till 31 Dec 2026, 23:59:59 Dhaka time (UTC+6)
BD = timezone(timedelta(hours=6))
last = datetime(2026, 12, 31, 23, 59, 59, tzinfo=BD)
orders = [datetime(2026, 12, 31, 17, 59, 59, tzinfo=timezone.utc),
datetime(2026, 12, 31, 18, 0, 0, tzinfo=timezone.utc)]
for o in orders:
local = o.astimezone(BD)
right = o <= last # compare instants
buggy = o.date() <= last.date() # compares UTC date
print(f"{local:%d %b %H:%M:%S} BD valid={right} buggy={buggy}")আসল আউটপুট (ব্রাউজারের Python):
float total: 1000.0000000000001 | over 1000? True
paisa total: 100000 | over 100000? False
next float above 1000.0: 1000.0000000000001
31 Dec 23:59:59 BD valid=True buggy=True
01 Jan 00:00:00 BD valid=False buggy=True
টাকা: চারটি দাম পরপর float-এ যোগ করলে ফল ১০০০-এর চেয়ে সামান্য বেশি, তাই t > 1000 সত্য: ঠিক ১০০০ টাকার অর্ডারেও ছাড় পেয়ে যাবে। ভুলটি দেখা দেয় ঠিক সীমার ওপরে, অন্য কোথাও নয়। পয়সায় পূর্ণ সংখ্যা (Decimal থেকে রূপান্তর করে) রাখলে যোগফল হুবহু 100000. তৃতীয় লাইন দেখায় float-এ 1000.0-এর পরের মানটি কত কাছে; এটি ব্যবসার ধাপ (০.০১) নয়, যন্ত্রের ধাপ। Test-এ ব্যবসার ধাপ ব্যবহার করুন, আর কোড টাকা কোন ধরনে রাখে, সেটি জেনে নিন।
সময়: UTC-তে ৩১ ডিসেম্বর ১৮:০০:০০ মানে ঢাকায় ১ জানুয়ারি রাত ১২টা: coupon-এর মেয়াদ শেষ। সঠিক তুলনা (দুটি মুহূর্তের) False দেয়; কিন্তু UTC-র তারিখ তুলনা করা কোড এখনো True বলে, আর আরও ছয় ঘণ্টা বলতে থাকবে। Test-এর মান দুটি এক সেকেন্ড দূরে, ঠিক সীমার দুই পাশে: সময়ের BVA এভাবেই হয়।
৭ · একাধিক input আর robustness testing
এতক্ষণ একটি input-এর সীমা দেখলাম। বাস্তবের form-এ input অনেক। Jorgensen-এর বইয়ে প্রচলিত boundary value testing-এর রূপগুলো ISTQB-এর ২-মান/৩-মান থেকে একটু আলাদা, কিন্তু বিশ্ববিদ্যালয় আর চাকরির পরীক্ষায় প্রায়ই আসে। প্রতিটি input-এর জন্য পাঁচটি মান নেওয়া হয়: min, min+ (ঠিক ওপরে), nominal (মাঝামাঝি সাধারণ মান), max− (ঠিক নিচে), max. আর একটি অনুমান: ভুল সাধারণত একটি input-এর কারণেই ঘটে, দুটির একসাথে চরম মানে নয়। একে বলে single-fault assumption. তাই একবারে একটি input সীমায় যায়, বাকিরা থাকে nominal-এ।
- Normal BVA: প্রতিটি input-এর ৪টি সীমার মান, বাকিরা nominal, সাথে সব-nominal একটি test: ৪n + ১.
- Robustness testing: সাথে প্রতিটি input-এর min−1 আর max+1, অর্থাৎ বৈধ সীমার বাইরের মান: ৬n + ১. দেখা হয় software অবৈধ মান ভদ্রভাবে প্রত্যাখ্যান করে কি না।
- Worst-case testing: single-fault অনুমান বাদ; প্রতিটি input-এর পাঁচ মানের সব মিশ্রণ: ৫n.
- Robust worst-case: সাতটি মানের সব মিশ্রণ: ৭n.
| রূপ | সূত্র | n = 2 | n = 3 |
|---|---|---|---|
| Normal BVA | 4n + 1 | 9 | 13 |
| Robustness | 6n + 1 | 13 | 19 |
| Worst-case | 5n | 25 | 125 |
| Robust worst-case | 7n | 49 | 343 |
উদাহরণ, n = 2: পণ্যের পরিমাণ q (১–১০, nominal ৫) আর ছাড়ের কোডের দৈর্ঘ্য L (৪–১২, nominal ৮)। Normal BVA-র ৯টি test: q = 1, 2, 9, 10 (L = 8), L = 4, 5, 11, 12 (q = 5), আর (5, 8). Robustness যোগ করে q = 0, 11 আর L = 3, 13. গুণের নিয়মে মিশ্রণ গোনার গণিত ডিসক্রিট ম্যাথ কোর্সের পর্ব ৩১-এ আছে। মিশ্রণ বাড়লে test দ্রুত বাড়ে; কম test-এ জোড়ায় জোড়ায় মিশ্রণ ঢাকার কৌশল পর্ব ১১ (Pairwise আর combinatorial testing)-এ।
দুই রীতি মিলিয়ে নিন: Jorgensen-এর min+ বৈধ দলের ভেতরের প্রতিবেশী, ISTQB-এর ২-মানে সেটি নেই, ৩-মানে আছে। আর robustness-এর min−1 ISTQB-এর ২-মানেই আছে (পাশের অবৈধ দলের নিকটতম মান)। তাই একই input-এর ISTQB ৩-মান set আর Jorgensen-এর robustness set প্রায় একই মান দেয়; তফাত শুধু Jorgensen-এর nominal আর আক্ষরিক ISTQB রীতির min−2 ও max+2. পরীক্ষার প্রশ্নে কোন রীতির নাম আছে, দেখে উত্তর দিন।
দুটি input যখন একটি নিয়মে জড়ানো, যেমন “পরিমাণ × একক দাম ১০০০-এর বেশি”, তখন সীমা আর একটি বিন্দু নয়, একটি রেখা। এমন সীমার test নিয়ে আলাদা একটি ধারা আছে, domain testing; সংক্ষেপে নিচের “আরও গভীরে” বাক্সে।
৮ · BVA-র ফাঁদ, coverage-এর হিসাব আর EP-র সাথে জোড়া
Coverage-এর হিসাব
BVA coverage = চালানো coverage item ÷ চিহ্নিত coverage item × ১০০. ধরুন coupon-এর ২-মান বিশ্লেষণে ৬টি item; আপনার suite চালায় 0, 1000, 1001 আর 3000. তাহলে ৪ ÷ ৬ = ৬৬.৭%. বাকি দুটি (1 আর 3001) যোগ করলে ১০০%. ৩-মানে item ১২টি, তাই একই চারটি test-এ coverage ৩৩.৩%. Coverage শুধু বলে বিশ্লেষণের কতটা চালানো হয়েছে; বিশ্লেষণে যে সীমা বাদ পড়েছে (যেমন 3010), সেটি এই হিসাবে কখনো আসে না।
EP আর BVA একসাথে
দুটি কৌশল প্রতিদ্বন্দ্বী নয়। প্রচলিত পথ: প্রতিটি partition থেকে একটি ভেতরের প্রতিনিধি (EP), আর প্রতিটি সীমায় ২-মান বা ৩-মান (BVA). Coupon-এ ২-মানের ৬টি আর EP-র ৪টি মিলে ১০টি test; §৪-এর হিসাবে ৬টি mutant-এর ৫টি ধরে। কেউ কেউ বলেন সীমার মানও তো partition-এর সদস্য, তাই আলাদা প্রতিনিধি লাগে না। M5 দেখায় কেন লাগে: ভেতরের মান এমন অংশ ছোঁয় যেখানে কোনো সীমা নেই।
সাধারণ ফাঁদ
- অস্পষ্ট শব্দ: “বেশি” বনাম “বা বেশি”, “পর্যন্ত”, “মধ্যে”। Coupon-এ “বেশি” (১০০০-এ ছাড় নেই), ফ্রি delivery-তে “বা বেশি” (২০০০-এ ফ্রি)। BVA-র প্রথম ফল প্রায়ই একটি প্রশ্ন, test নয়।
- লুকানো সীমা: গোল করা (3010), byte-দৈর্ঘ্য (72), সময় অঞ্চল, ডেটাবেসের কলামের আকার, integer overflow. Requirement-এর পাশাপাশি data-র ধরনও পড়ুন।
- ক্রমহীন ঘরে BVA: জেলা বা payment method-এ সীমা নেই; সেখানে EP বা decision table (পর্ব ০৯)।
- একসাথে দুটি অবৈধ মান: phone-এর দৈর্ঘ্যের সীমা test করতে গিয়ে তৃতীয় অঙ্কও ভুল দিলে বোঝা যায় না কোন নিয়ম প্রত্যাখ্যান করল। প্রতিটি test-এ একটিই সীমা নড়ান।
- Output-এর সীমা ভোলা: ছাড়ের ফলও ক্রমযুক্ত (0, 100 থেকে 299, 300). “ঠিক 300 আসে কখন প্রথম” প্রশ্নটি input-এ 3000 দেয়, আর “cap ছাড়া 301 হতো কখন” প্রশ্নটি 3010.
- সংখ্যা ছাড়া অন্য ধরন: “abc”, খালি ঘর বা 45.5 দিলে কী হয়, সেটি BVA-র কাজ নয়; পর্ব ০৭-এর ধরনভিত্তিক অবৈধ partition আর পর্ব ১৪-এর error guessing.
আরও গভীরে: দুই বা বেশি input একটি রৈখিক শর্তে জড়ালে সীমা হয় একটি রেখা বা তল। Lee White আর Edward Cohen ১৯৮০ সালে IEEE Transactions on Software Engineering-এ “A Domain Strategy for Computer Program Testing” প্রবন্ধে এমন সীমায় ON বিন্দু (ঠিক রেখার ওপর) আর OFF বিন্দু (রেখার খুব কাছে, অন্য পাশে) বেছে নেওয়ার পদ্ধতি দেন; Beizer পরে একে domain testing নামে ছড়িয়ে দেন। মূল দাবিটি ছিল, কয়েকটি ভালো করে বাছা বিন্দু সীমা সরে যাওয়া বা হেলে পড়ার মতো ভুল ধরতে পারে। Trade-off: input যত বেশি, বিন্দু তত বেশি, আর অরৈখিক শর্তে পদ্ধতিটি দুর্বল; তখন property-based testing (পর্ব ৫৮) বা solver-ভিত্তিক যাচাই কাজে আসে।
পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এমন প্রশ্ন খুব চেনা:
- বয়স ১৮–৬০ বৈধ; ২-মান BVA-র মান? — 17, 18, 60, 61.
- একই ঘরে ৩-মান BVA? — ISTQB-এর আক্ষরিক রীতিতে 16, 17, 18, 19, 59, 60, 61, 62; শুধু বৈধ কিনারা ধরলে 17, 18, 19, 59, 60, 61.
- ৩-মান কখন দরকার? — যখন
<=ভুল করে==হতে পারে, বা ঝুঁকি বেশি; সীমার ভেতরের প্রতিবেশী সেই ভুল ধরে। - দুই input-এ robust worst-case-এ কয়টি test? — ৭² = ৪৯.
- BVA কোথায় খাটে না? — ক্রমহীন input-এ, যেমন জেলার নাম বা payment method.
৯ · AI-এর যুগে boundary value
AI assistant-কে “coupon ফাংশনের test লিখে দাও” বললে প্রায়ই পাবেন ৫০০, ১৫০০, ৫০০০ টাকার মতো সুন্দর গোল মান: শুধু happy path, সীমা নেই। আরও বিপজ্জনক অভ্যাস: AI কোড পড়ে কোড যা করে সেটিকেই expected ধরে নেয়। কোডে >= থাকলে সে লিখবে “1000 টাকায় ছাড় 100”, আর §৫-এর ভুল কোডে test সবুজ থাকবে। এ ছাড়া AI “৩-মান BVA” বলে আসলে ২-মানের মান দিতে পারে, অস্তিত্বহীন tool option বানাতে পারে, test না চালিয়েই “সব পাস” দাবি করতে পারে, আর লুকানো সীমা (গোল করা, byte, সময় অঞ্চল) প্রায় কখনো নিজে থেকে তোলে না।
AI-কে কোড নয়, requirement দিন, আর কোন রীতিতে গুনতে হবে স্পষ্ট বলে দিন:
AI-লেখা boundary test হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১Off-by-one ভুল এত সাধারণ কেন — দোষ কি developer-এর অমনোযোগের, না সংখ্যা লেখার ধরনের?
দুটোই, তবে দ্বিতীয়টি বেশি গভীর। মানুষ সাধারণত “১ থেকে ১০” বলে, যেখানে দুই প্রান্তই ধরা। কিন্তু অনেক প্রোগ্রামিং ভাষা আর লাইব্রেরি ব্যবধান লেখে আধা-খোলা রূপে: Python-এর range(1, 11)-এ ১ আছে, ১১ নেই; slicing-এ s[0:8] মানে প্রথম আটটি। এক মাথায় দুই রীতি পাশাপাশি থাকলে কোনো একদিন একটি অন্যটির জায়গা নেয়।
Edsger Dijkstra ১৯৮২ সালে একটি ছোট হাতে লেখা নোটে (EWD831, “Why numbering should start at zero”) যুক্তি দেন, ব্যবধান লেখার সবচেয়ে কম ভুলপ্রবণ রূপ হলো নিচের প্রান্তসহ আর ওপরের প্রান্ত বাদ, অর্থাৎ a ≤ i < b. এতে দৈর্ঘ্য সরাসরি b − a, আর পাশাপাশি দুটি ব্যবধান ফাঁক বা ওভারল্যাপ ছাড়াই জোড়া লাগে। Python-এর নকশা এই ধারণার সাথে মেলে।
সমস্যা হলো, ব্যবসার requirement এই রীতি মানে না। “১০০০ টাকার বেশি”, “২০০০ বা বেশি”, “৮ থেকে ৬৪ অক্ষর”, “৩১ ডিসেম্বর পর্যন্ত”: প্রতিটি বাক্যে প্রান্ত ধরা হবে কি না আলাদা, আর বাংলায় “পর্যন্ত” শব্দটি প্রায়ই দুই অর্থে চলে। Developer-কে প্রতিবার বাক্য থেকে <, <=, >, >=-এ অনুবাদ করতে হয়। চারটি চিহ্ন, প্রতিটি সীমায় একটি সিদ্ধান্ত; শত শত সীমার একটিতে ভুল হওয়াই স্বাভাবিক।
আরেকটি কারণ মনস্তাত্ত্বিক: পরীক্ষার সময় developer নিজের মাথার মডেল দিয়ে মান বাছেন, যা ওই একই অনুবাদ থেকে এসেছে। তাই নিজের >= ভুল নিজের test-ও ফসকায়। Tester-এর সুবিধা হলো requirement-এর বাক্য থেকে আলাদাভাবে সীমা বের করা। এজন্য BVA-র সবচেয়ে বড় ফল অনেক সময় test নয়, প্রশ্ন: “ঠিক ২০০০ টাকায় কি ফ্রি?”
মূল উপলব্ধি: সীমার ভুল ব্যক্তিগত দুর্বলতা নয়, ভাষা আর কোডের রীতির অমিল থেকে জন্মানো একটি স্থায়ী ঝুঁকি; তাই সীমাকে আলাদা করে লিখে, আলাদা করে test করাই একমাত্র ভরসাযোগ্য প্রতিকার।
প্র ০২যে সীমা requirement-এ লেখাই নেই, tester সেটি খুঁজবেন কীভাবে? ইতিহাসের কিছু উদাহরণ কী বলে?
ইতিহাসের সবচেয়ে আলোচিত software-সীমাগুলোর প্রায় কোনোটিই ব্যবসার নিয়মে লেখা ছিল না; ছিল data রাখার ধরনে।
- Y2K: জায়গা বাঁচাতে বহু পুরোনো system সাল রাখত দুই অঙ্কে। ১৯৯৯ থেকে ২০০০-এ যাওয়া মানে 99 থেকে 00, যা অনেক হিসাবে ১৯০০ হয়ে যেত। সারা বিশ্বে বিপুল খরচে কোড বদলানো হয়।
- ২০৩৮ সমস্যা: অনেক system সময় রাখে ১৯৭০ সাল থেকে গোনা সেকেন্ডে, signed 32-bit integer-এ। এই সংখ্যার সর্বোচ্চ মান ছোঁয় ১৯ জানুয়ারি ২০৩৮, 03:14:07 UTC-তে; পরের সেকেন্ডে মান উল্টে ১৯০১ সালে চলে যায়। নতুন system 64-bit ব্যবহার করে, কিন্তু পুরোনো যন্ত্র আর file format এখনো ঝুঁকিতে।
- GPS week rollover: GPS সংকেতে সপ্তাহের নম্বর রাখা হতো ১০ bit-এ, অর্থাৎ ১০২৪ সপ্তাহ (প্রায় ১৯.৭ বছর) পরপর শূন্যে ফেরে। ১৯৯৯ সালের আগস্টে আর ২০১৯ সালের এপ্রিলে এমন ফেরা ঘটে, আর কিছু পুরোনো receiver ভুল তারিখ দেখায় বলে প্রতিবেদন আছে।
সাধারণ সূত্র: সীমাটি এসেছে প্রযুক্তির সিদ্ধান্ত থেকে, যেমন কত bit, কত অঙ্ক, কোন সময় অঞ্চল, কোন encoding. বাজারঘরে একই ধাঁচের প্রশ্ন: অর্ডার নম্বর কোন ধরনের integer-এ রাখা? Database-এ নামের কলাম কত অক্ষরের? Payment-এর mock সর্বোচ্চ কত টাকা নেয়? SMS-এ বাংলা লেখা কত অক্ষরে কাটা পড়ে?
Tester-এর কৌশল তিনটি। এক, data dictionary আর API schema পড়ুন: প্রতিটি ঘরের ধরন আর দৈর্ঘ্য একটি সম্ভাব্য সীমা। দুই, developer-কে সরাসরি জিজ্ঞেস করুন “এই মান কোথায় রাখা হয়?” তিন, চেনা প্রযুক্তি-সীমার একটি তালিকা রাখুন (27, 215, 231, 255 byte, মাসের শেষ দিন, অধিবর্ষ, মধ্যরাত) আর প্রতিটি নতুন ঘরে মিলিয়ে দেখুন।
মূল উপলব্ধি: BVA শুরু হয় requirement-এর সীমা থেকে, কিন্তু অভিজ্ঞ tester সেখানে থামেন না; data কোথায়, কোন ধরনে, কোন আকারে থাকে, তা জানলেই লুকানো সীমা দৃশ্যমান হয়।
প্র ০৩সবসময় ৩-মান BVA করলেই তো নিরাপদ — তাহলে ২-মান BVA টিকে আছে কেন?
কারণ test-এর খরচ আছে, আর দুই পদ্ধতির পার্থক্য সব ভুলে সমান নয়। এই পর্বের coupon উদাহরণে ২-মান set-এ ৬টি test, ৩-মান set-এ ১২টি: দ্বিগুণ। এক ঘরে এটা তুচ্ছ, কিন্তু একটি checkout form-এ বিশটি ক্রমযুক্ত ঘর থাকলে, প্রতিটি নতুন release-এ manual test হলে, বা প্রতিটি test-এ ডেটাবেস আর browser লাগলে পার্থক্য দিনের হিসাবে দাঁড়ায়।
কোন ভুল কোন পদ্ধতি ধরে, তা ভাবা যায় সীমার শর্তের রূপ দিয়ে। শর্ত যদি x <= 10, সম্ভাব্য এক-চিহ্নের ভুল: <, >=, >, ==, !=, আর সংখ্যা এক ঘর সরানো। ২-মানের 10 আর 11 এর বেশিরভাগ ধরে; শুধু == ফসকায়, কারণ 10-এ দুটিই সত্য আর 11-এ দুটিই মিথ্যা। ISTQB-এর syllabus ঠিক এই উদাহরণ দেয়: ৩-মানের 9 সেই ভুল ধরে। §৪-এর হিসাবেও ৩-মান দুটি বাড়তি mutant ধরেছে (M4 আর গোল করার M6).
এই চিন্তার পেছনে mutation testing-এর একটি অনুমান কাজ করে, competent programmer hypothesis: অভিজ্ঞ developer-এর ভুল সাধারণত সঠিক কোডের খুব কাছাকাছি, এক চিহ্ন বা এক সংখ্যার তফাত। এই অনুমান সত্য হলে ছোট ছোট mutant-এর বিরুদ্ধে test set মাপা অর্থবহ। কিন্তু এটি একটি অনুমান; বড় নকশার ভুল বা ভুল বোঝা requirement কোনো BVA-ই ধরবে না।
তাই বাস্তব সিদ্ধান্ত ঝুঁকিভিত্তিক (পর্ব ৭৩)। টাকা, ওষুধের মাত্রা, নিরাপত্তার সীমা: ৩-মান, আর সাথে EP-র ভেতরের মান। কম ঝুঁকির প্রদর্শনী-ঘর (যেমন profile-এর নামের দৈর্ঘ্য): ২-মান যথেষ্ট। ISO/IEC/IEEE 29119-4-এও দুই রূপকেই বৈধ পদ্ধতি হিসেবে রাখা হয়েছে বলে আমরা জানি, বেছে নেওয়ার দায় test strategy-র।
মূল উপলব্ধি: ৩-মান “ভালো” আর ২-মান “খারাপ” নয়; প্রতিটি বাড়তি test একটি নির্দিষ্ট ধরনের ভুল ধরার দাম, আর সেই দাম দেওয়ার যুক্তি আসে ঝুঁকি থেকে।
প্র ০৪দশমিক সংখ্যার “ক্ষুদ্রতম ধাপ” নিয়ে এত সতর্কতা কেন — বাস্তবে এমন ভুলের দাম কতটা হতে পারে?
দুটি বিখ্যাত ঘটনা দাম বোঝায়। প্রথমটি ১৯৯১ সালের উপসাগরীয় যুদ্ধের। মার্কিন GAO-র ১৯৯২ সালের প্রতিবেদন অনুযায়ী, Patriot ক্ষেপণাস্ত্র-প্রতিরোধ ব্যবস্থার ঘড়ি সময় গুনত এক সেকেন্ডের দশ ভাগের এক ভাগ হিসেবে, আর ০.১ সংখ্যাটি binary-তে হুবহু রাখা যায় না; ২৪-bit register-এ রাখতে গিয়ে প্রতিবার সামান্য কেটে যেত। প্রায় ১০০ ঘণ্টা টানা চলার পর জমা ভুল দাঁড়ায় প্রায় ০.৩৪ সেকেন্ডে, যা দ্রুতগামী লক্ষ্যবস্তুর অবস্থান হিসাবে বড় পার্থক্য। Dhahran-এ একটি Scud ক্ষেপণাস্ত্র আটকানো যায়নি, আর ২৮ জন সৈন্য নিহত হন।
দ্বিতীয়টি টাকার জগতের। Vancouver Stock Exchange ১৯৮২ সালে একটি নতুন সূচক চালু করে, শুরুর মান ১০০০. প্রতিটি লেনদেনের পর সূচক নতুন করে হিসাব হতো আর তিন দশমিক ঘরে কেটে রাখা হতো, গোল করে নয়। প্রতিবার হারানো অংশ ক্ষুদ্র, কিন্তু দিনে হাজারো লেনদেন। প্রায় দুই বছর পর সূচক দেখাচ্ছিল পাঁচশোর কাছাকাছি; সঠিকভাবে হিসাব করলে তা ছিল হাজারের ওপরে, এমনটাই প্রকাশিত বিবরণ।
দুই ঘটনার শিক্ষা এক: কম্পিউটারের সংখ্যার নিজস্ব ধাপ আছে, যা ব্যবসার ধাপের সাথে না মিললে ভুল জমে, আর সীমার কাছে সেই ভুল সিদ্ধান্ত উল্টে দেয়। §৬-এ দেখেছেন চারটি দাম যোগ করে ১০০০.০০ হওয়ার কথা, কিন্তু float বলে সামান্য বেশি; coupon-এর > 1000 শর্ত তখন ভুল উত্তর দেয়। গোল করার নিয়মও লুকানো সীমা বানায়: ভগ্নাংশ বাদ দেওয়ায় cap-এর আসল সীমা 3010.
Tester-এর করণীয়: requirement-এ জিজ্ঞেস করুন টাকা কত দশমিক পর্যন্ত, গোল করার নিয়ম কী (কাটা, কাছের, ব্যাংকারের গোল), আর সীমার মান নিন ব্যবসার ধাপে (১০০০.০০ আর ১০০০.০১)। Developer-এর সাথে নিশ্চিত হোন টাকা পয়সায় পূর্ণ সংখ্যা বা Decimal-এ রাখা হয়, float-এ নয়। আর যোগফল তৈরি হয় এমন test রাখুন (কয়েকটি পণ্য মিলে ঠিক সীমা), কারণ এক মানের input-এ এই ভুল দেখা যায় না।
মূল উপলব্ধি: দশমিকের সীমায় দুটি ধাপ কাজ করে, ব্যবসার আর যন্ত্রের; BVA-র মান বাছবেন ব্যবসার ধাপে, কিন্তু ঝুঁকি খুঁজবেন যন্ত্রের ধাপে।
প্র ০৫Property-based testing, fuzzing আর AI test generator থাকতে হাতে সীমা বের করার দরকার কি এখনো আছে?
মজার ব্যাপার হলো, এই নতুন tool-গুলো নিজেরাই BVA-র ধারণা ভেতরে রেখেছে। Property-based testing-এর জনপ্রিয় Python লাইব্রেরি Hypothesis এলোমেলো input দিয়ে ভুল পেলে input-টিকে ধাপে ধাপে ছোট করে (shrinking), যতক্ষণ ভুলটি থাকে। ফলে প্রায়ই সে যে উদাহরণ দেখায় তা সীমার ঠিক পাশের মান, যেমন “1000-এ ভুল”। আবার fuzzer AFL এলোমেলো বদলের পাশাপাশি কিছু “আকর্ষণীয় মান” বসিয়ে দেখে, যেমন 0, −1, 127, 128, 255, 256, 1024, 32767: এগুলো integer-এর ধরনের সীমা। অর্থাৎ যন্ত্রও জানে ভুল কিনারায় থাকে।
তাহলে মানুষের কাজ কী? তিনটি জিনিস tool নিজে দিতে পারে না। প্রথমত, ব্যবসার সীমা: ১০০০ টাকা কেন বিশেষ, tool জানে না, যদি না আপনি বলেন। এলোমেলো integer-এর মধ্যে ঠিক 1000 পড়ার সম্ভাবনা কম। দ্বিতীয়ত, সঠিক উত্তর: fuzzer crash ধরে, কিন্তু 1000-এ ছাড় 0 না 100, তা বলতে লাগে requirement থেকে আসা test oracle. Property লিখতেও requirement বুঝতে হয়। তৃতীয়ত, অস্পষ্টতা ধরা: “পর্যন্ত” মানে কী, তা কোনো tool জিজ্ঞেস করে না।
AI test generator-এর ক্ষেত্রেও একই কথা, আর §৯-এ দেখেছেন সে প্রায়ই কোড থেকে expected নেয়। তাই কার্যকর মিশ্রণ: requirement থেকে হাতে বা ছোট script-এ BVA (স্পষ্ট, পর্যালোচনাযোগ্য, প্রতিটি মানের যুক্তি লেখা), তারপর property-based testing (পর্ব ৫৮) আর fuzzing (পর্ব ৬০) দিয়ে আপনার ভাবনার বাইরের জায়গা খোঁজা, আর mutation testing (পর্ব ৫৯) দিয়ে মেপে দেখা test-গুলো আসলে কতটা ধরে। বাজারঘরের coupon-এ এর মানে: 1000, 1001, 3000 আর 3010-এর হাতে লেখা test, আর তার পাশে “ছাড় কখনো ৩০০-র বেশি নয়” জাতীয় একটি property.
মূল উপলব্ধি: BVA একটি চিন্তার কাঠামো, শুধু একটি হাতের কৌশল নয়; নতুন tool সেই কাঠামোকে দ্রুত করে, কিন্তু কোন সীমা গুরুত্বপূর্ণ আর সেখানে কী হওয়া উচিত, সেই সিদ্ধান্ত এখনো requirement বোঝা মানুষের।
অনুশীলন
কাগজে-কলমে করুন; শেষে উত্তর মিলিয়ে নিন।
-
Test design: নিয়ম: “ঢাকার ভেতরে delivery charge ৬০ টাকা, তবে অর্ডার ২০০০ টাকা বা বেশি হলে ফ্রি; মোট ১-এর কম হলে error.” মোট টাকা পূর্ণ সংখ্যা। ঢাকার ভেতরের জন্য partition, সীমার মান, ২-মান আর ৩-মান set লিখুন, প্রতিটির expected charge-সহ। Coupon-এর সাথে কোথায় পার্থক্য?
Partition: ≤0 অবৈধ │ 1–1999 → ৬০ │ ≥2000 → ০. সীমার মান 0, 1, 1999, 2000 (৪টি)। ২-মান set একই চারটি: 0 → error, 1 → 60, 1999 → 60, 2000 → 0. ৩-মান set ৮টি: −1, 0 → error; 1, 2, 1998, 1999 → 60; 2000, 2001 → 0.
পার্থক্য: এখানে “বা বেশি”, তাই 2000 নিজেই ফ্রি দলের সর্বনিম্ন; coupon-এ “বেশি”, তাই 1000 ছাড়হীন দলের সর্বোচ্চ। একই ধরনের বাক্যে প্রান্ত উল্টো দিকে পড়ে। সাথে একটি test রাখুন: ঢাকার বাইরে ঠিক ২০০০ টাকায় charge ১২০, যাতে ফ্রি-র নিয়ম ভুল করে বাইরে ছড়িয়ে না পড়ে। (দুটি input মেশানোর পূর্ণ হিসাব পর্ব ০৯-এর decision table-এ।)
-
Failure পড়ুন: নিচের test আর তার আসল আউটপুট (desktop Python 3.14-এ চালানো, file path বদলে নিরপেক্ষ নাম দেওয়া, traceback-এর মাঝের লাইন ছাঁটা) দেখে বলুন: কোন সীমায় ভুল, কোডে ঠিক কী বদলাতে হবে, আর EP-র একটি প্রতিনিধি (যেমন ৩০ অক্ষর) কি এটি ধরত?
def password_ok(p): return 8 <= len(p) < 64 for n, ok in [(7, False), (8, True), (64, True), (65, False)]: with self.subTest(length=n): self.assertEqual(password_ok("a" * n), ok) FAIL: test_lengths (__main__.PasswordLength.test_lengths) (length=64) … AssertionError: False != Trueভুল ওপরের সীমায়: ৬৪ অক্ষরের password, যা বৈধ হওয়ার কথা (expected
True), কোড বাতিল করছে (actualFalse). কারণlen(p) < 64; হওয়া উচিতlen(p) <= 64. বাকি তিনটি subtest পাস করেছে, তাই বার্তায় শুধু(length=64). ৩০ অক্ষরের EP-প্রতিনিধি দুই কোডেইTrueদেয়, তাই ধরত না। এটি §৪-এর M2-র মতোই সীমা এক ঘর সরে যাওয়ার ভুল। -
Test-এর ভুল খুঁজুন: একজন tester phone number-এর (১১ অঙ্ক, শুরু 01, তৃতীয় অঙ্ক 3 থেকে 9) BVA test লিখেছেন। এই তালিকায় দুটি সমস্যা আছে; খুঁজে বের করুন।
TC-1 "01712345678" expected: valid # length 11 TC-2 "017123456789" expected: invalid # length 12 TC-3 "0121234567" expected: invalid # length 10 TC-4 "01312345678" expected: valid # 3rd digit 3 TC-5 "01212345678" expected: valid # 3rd digit 2TC-5-এর expected ভুল: তৃতীয় অঙ্ক 2 অবৈধ দলের সর্বোচ্চ মান, তাই expected “invalid”. লেখা অবস্থায় সঠিক কোডে এই test fail করবে, আর কেউ “ঠিক” করতে গিয়ে কোড ভেঙে দিতে পারে।
TC-3-এ একসাথে দুটি অবৈধ মান: দৈর্ঘ্য ১০ আর তৃতীয় অঙ্ক 2. Validator দৈর্ঘ্যের নিয়ম ভুলে গেলেও তৃতীয় অঙ্কের কারণে “invalid” আসবে, test পাস করবে, ভুল লুকিয়ে থাকবে। দৈর্ঘ্যের test-এ বাকি সব বৈধ রাখুন, যেমন
"0171234567". -
গুনে দেখুন: দুটি input: পণ্যের পরিমাণ (১–১০) আর ছাড়ের কোডের দৈর্ঘ্য (৪–১২)। Normal BVA, robustness, worst-case আর robust worst-case-এ কয়টি test? আর পরিমাণের ঘরের ISTQB ২-মান বিশ্লেষণে (বৈধ ১–১০, এর নিচে আর ওপরে অবৈধ) চারটি coverage item; একটি suite শুধু 1 আর 10 চালালে BVA coverage কত?
n = 2: normal ৪×২ + ১ = ৯; robustness ৬×২ + ১ = ১৩; worst-case ৫² = ২৫; robust worst-case ৭² = ৪৯.
পরিমাণের ২-মান item: 0, 1, 10, 11. Suite চালায় 1 আর 10, অর্থাৎ ২ ÷ ৪ = ৫০%. বাকি দুটি অবৈধ মান (0 আর 11) যোগ করলে ১০০%. শুধু বৈধ সীমা test করা খুব সাধারণ ফাঁক: software অবৈধ মান প্রত্যাখ্যান করে কি না, তা তখন অজানা থাকে।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমBoundary value analysis-এর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Requirement থেকে input, তার ধরন আর ক্ষুদ্রতম ধাপ ঠিক করা
- বৈধ আর অবৈধ partition ক্রম অনুযায়ী সাজানো
- প্রতিটি partition-এর সর্বনিম্ন আর সর্বোচ্চ মান লেখা
- ২-মান বা ৩-মান বেছে coverage item-এর তালিকা বানানো
- Requirement থেকে প্রতিটি মানের expected result লেখা
- Test চালিয়ে coverage % হিসাব করা
একটি ঘরে বয়স 18 থেকে 60 (দুই প্রান্তসহ, পূর্ণ সংখ্যা) বৈধ, বাকি সব অবৈধ। ISTQB-এর ২-মান BVA অনুযায়ী কোন চারটি মান test করবেন?
- 18, 19, 59, 60
- 17, 18, 60, 61
- 17, 18, 19, 59, 60, 61
- 0, 18, 60, 100
শর্ত x <= 10 (x পূর্ণ সংখ্যা) কোডে ভুল করে x == 10 লেখা হয়েছে। কোন input এই ভুল ধরবে?
- 10
- 11
- 9
- কোনো input-ই ধরবে না
নিয়ম: মোট টাকা (পূর্ণ সংখ্যা) 1000-এর বেশি হলে ছাড়। কোডে লেখা total >= 1000. কোন test ভুলটি ধরে?
- 1001
- 1000
- 1500
- 999
একটি ঘরের boundary value analysis-এ মোট ৮টি coverage item চিহ্নিত হয়েছে; test suite এর ৬টি চালায়। BVA coverage কত?
- ৬০%
- ১০০%
- ৭৫%
- ২৫%
দাম পয়সাসহ (দুই দশমিক ঘর), নিয়ম: “মোট 1000.00 টাকার বেশি হলে ছাড়”। এই সীমায় ২-মান BVA-র মান দুটি কী?
- 1000.00 আর 1000.01
- 999 আর 1000
- 1000 আর 1001
- 999.99 আর 1000.00
দুটি স্বাধীন integer input-এ robust worst-case boundary value testing (প্রতিটির জন্য min−1, min, min+1, nominal, max−1, max, max+1-এর সব মিশ্রণ)-এ কয়টি test লাগে?
- ১৩
- ২৫
- ১৪
- ৪৯
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- BVA খাটে শুধু ক্রমযুক্ত partition-এ; প্রতিটি partition-এর সর্বনিম্ন আর সর্বোচ্চ মানই সীমার মান।
- ২-মান: সীমার মান আর পাশের দলের নিকটতম মান। ৩-মান: সীমার মান আর দুই প্রতিবেশী;
<=থেকে==ধাঁচের ভুল শুধু এটিই ধরে। - প্রথমে ক্ষুদ্রতম ধাপ জানুন: টাকা, পয়সা, অক্ষর, byte, সেকেন্ড। Expected মান সবসময় requirement থেকে।
- লুকানো সীমা খুঁজুন: গোল করা, byte-দৈর্ঘ্য, সময় অঞ্চল, float. BVA-র সাথে EP-র ভেতরের মান রাখুন।
- একাধিক input-এ normal ৪n+১, robustness ৬n+১, worst-case ৫n, robust worst-case ৭n; coverage = চালানো ÷ চিহ্নিত item.
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ০৯ · Decision table আর cause-effect — নিয়মের সব মিশ্রণপরবর্তী পর্বকয়েকটি শর্তের সব মিশ্রণ সাজিয়ে test করার টেবিল।
- সফটওয়্যার টেস্টিং ও QA · কোর্স হোম৮২টি পর্ব১৪টি মডিউলের পুরো রোডম্যাপ।
- সফটওয়্যার ইঞ্জিনিয়ারিং ও Git · পর্ব ৪৭পাশের ট্র্যাকTest design-এর কৌশলগুলো এক পর্বে, সংক্ষেপে।
- সফটওয়্যার ইঞ্জিনিয়ারিং ও Git · পর্ব ৫০পাশের ট্র্যাকCoverage, complexity আর mutation testing-এর প্রথম স্বাদ।
- ডিসক্রিট ম্যাথ · পর্ব ৩১গভীরে যানগুণ আর যোগের নিয়ম: worst-case test গোনার গণিত।