এই পর্বে যা শিখবেন
- একটি লিখিত নিয়ম থেকে state, event, guard আর action আলাদা করে state diagram আঁকা
- State table পূরণ করে বৈধ আর অবৈধ ঘর গোনা, আর requirement-এর ফাঁক খুঁজে প্রশ্ন তোলা
- All states, 0-switch, 1-switch আর all transitions coverage-এর সংজ্ঞা, গণনা আর শতাংশ বের করা
- Coverage মাপ থেকে test sequence বানিয়ে আসল unittest চালানো, আর seeded defect ধরা
- State explosion, লুকানো state, সময়ভিত্তিক event আর AI-লেখা state test-এর ফাঁদ চেনা
১ · ফল যখন অতীতের ওপর নির্ভর করে
পর্ব ০৭ (equivalence partitioning) আর পর্ব ০৮ (boundary value analysis)-এ একটি ঘরের input ভাগ করেছেন; পর্ব ০৯ (decision table)-এ একই মুহূর্তের কয়েকটি শর্তের মিশ্রণ দেখেছেন। এই তিন কৌশলের একটি সাধারণ ধারণা আছে: একই input দিলে একই ফল। কিন্তু অনেক system-এ তা খাটে না। ফল নির্ভর করে আগে কী ঘটেছে তার ওপর।
মোবাইল রিচার্জের কথা ভাবুন। রিচার্জ চাওয়ার পর অনুরোধটি “অপেক্ষায়” থাকে। সফল হলে টাকা কাটা যায়, ব্যর্থ হলে আবার চেষ্টা করা যায়। একই “আবার চেষ্টা” বোতাম ব্যর্থ অনুরোধে কাজ করে, কিন্তু সফল অনুরোধে চাপলে দ্বিতীয়বার টাকা কাটা উচিত নয়। বোতাম একই, input একই; পার্থক্য শুধু অনুরোধটি এখন কোন অবস্থায় আছে। ঠিক এই অবস্থা আর অবস্থা-বদল ধরে test করাই state transition testing.
বাজারঘরের অর্ডারও এমন। ক্রেতা অর্ডার দিলেন, টাকা দিলেন, গুদামে প্যাক হলো, কুরিয়ারে গেল, পৌঁছাল। মাঝপথে বাতিল করা যায়, কিন্তু কুরিয়ারে চলে যাওয়ার পর আর নয়। বাতিলের পর টাকা দেওয়া থাকলে ফেরত যায়। “বাতিল” event-টি কখন বৈধ, কখন অবৈধ, তা কোনো একক input দেখে বলা যায় না; বলতে হয় অর্ডারের ইতিহাস দেখে। এই ধরনের আচরণের জন্য black-box কৌশলটির নাম state transition testing: system-এর আচরণকে একটি state machine (অবস্থার যন্ত্র) হিসেবে আঁকা, তারপর সেই মডেল থেকে নিয়মমাফিকভাবে test বের করা।
কোথায় এই কৌশল দরকার, চেনার সহজ উপায়: requirement-এ “আগে”, “পরে”, “যতক্ষণ না”, “একবার … হলে আর …” জাতীয় শব্দ থাকলে, বা একই বোতামের আচরণ পর্দার অবস্থাভেদে বদলালে। উদাহরণ: login-এ তিনবার ভুল OTP দিলে account আটকে যাওয়া, টিকিট সংরক্ষণ থেকে পরিশোধ, ফর্মের ধাপ (wizard), ATM, লিফট, ভিডিও player-এর play/pause, আর প্রায় সব workflow ও API resource-এর জীবনচক্র।
আগে কোথায় দেখেছেন: সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৪৭-এ বাস-টিকিটের একটি ছোট উদাহরণে কৌশলটির পরিচয় আছে, আর একই কোর্সের পর্ব ৩০-এ UML state machine diagram আঁকার নিয়ম। গাণিতিক ভিত্তি, অর্থাৎ finite automaton, পাবেন ডিসক্রিট ম্যাথ কোর্সের পর্ব ৭৪-এ। এখানে সেগুলো আবার শেখানো হবে না; এই পর্বে পূর্ণ পদ্ধতি, গণনার সূত্র, অনেক উদাহরণ আর আসল test চালানো।
২ · চারটি উপাদান — state, event, guard আর action
একটি state machine মডেলে চারটি জিনিস চিনতে হয়। প্রতিটির সংজ্ঞা ISTQB-এর syllabus আর ISO/IEC/IEEE 29119-4-এর ধারণা অনুসারে, আমাদের ভাষায়:
🟦 State (অবস্থা)
এমন একটি অবস্থা, যেখানে জিনিসটি কিছু সময় থাকে, আর যেখানে থাকাকালীন প্রতিটি event-এ তার সাড়া নির্দিষ্ট। যেমন Paid: টাকা পাওয়া গেছে, এখনো প্যাক হয়নি।
⚡ Event (ঘটনা)
বাইরে থেকে আসা কিছু, যা state বদলাতে পারে: ক্রেতা “বাতিল” চাপলেন, payment gateway “সফল” জানাল, কুরিয়ার “পৌঁছেছে” পাঠাল, বা সময় পার হলো।
🚦 Guard (শর্ত)
Event এলেও transition হবে কি না, তা ঠিক করা একটি শর্ত; বন্ধনীতে লেখা হয়, যেমন refund [paid]. শর্ত মিথ্যা হলে event প্রত্যাখ্যাত।
⚙️ Action (কাজ)
Transition-এর সময় system যা করে: টাকা কাটা, SMS পাঠানো, স্টক ফেরত দেওয়া। লেখা হয় event [guard] / action আকারে। Test-এ শুধু নতুন state নয়, action-ও যাচাই করতে হয়।
এক state থেকে আরেক state-এ যাওয়াকে বলে transition, আর তীরের বন্ধনীর শর্তটিকে বলে guard condition. একটি transition-এর পূর্ণ রূপ: আগের state, event, guard, action, নতুন state. এবার বাজারঘরের order status-এর নিয়ম, পুরো কোর্সে যা একই থাকবে:
অর্ডার দেওয়া হলে state Placed. টাকা দিলে Paid, গুদামে প্যাক হলে Packed, কুরিয়ারে দিলে Shipped, পৌঁছালে Delivered. Shipped হওয়ার আগে যেকোনো সময় ক্রেতা বাতিল করতে পারেন (Cancelled). বাতিলের আগে টাকা দেওয়া হয়ে থাকলে টাকা ফেরত হয় (Refunded). Delivered আর Refunded শেষ অবস্থা।
এই অনুচ্ছেদ থেকে ৭টি state আর ৬টি event পাওয়া যায়: pay, pack, ship, deliver, cancel, refund. বৈধ transition ৮টি, যাদের নাম দেব T1 থেকে T8; এই নামগুলোই পরে test-এর coverage item হবে। নিচের ছবিতে মডেলটি দেখুন।
বাজারঘরের order status — state diagram
Order status state machine: 7 states, 8 valid transitions T1–T8; red dashed arrow = an invalid transition
[paid] হলো guard: টাকা না দিয়ে বাতিল করা অর্ডারে refund অবৈধ। লাল তীরটি মডেলের অংশ নয়; এটি সেই পথ, যা system-এ খোলা থাকলে defect.ছবিতে একটি সূক্ষ্ম ব্যাপার লক্ষ করুন। Cancelled একটি state, কিন্তু সেখানে refund event বৈধ কি না নির্ভর করে একটি লুকানো তথ্যের ওপর: টাকা দেওয়া হয়েছিল কি না। এই তথ্য ছবির বাক্সে নেই, guard-এ আছে। এমন মডেলকে বলে extended finite state machine: state ছাড়াও কিছু variable থাকে, আর guard সেগুলো পড়ে। বিকল্প হলো Cancelled-কে দুটি state-এ ভাঙা (“বাতিল, টাকা ফেরত বাকি” আর “বাতিল, টাকা নেওয়া হয়নি”)। দুটি নকশাই চলে; যেটিই নিন, test-এ guard-এর দুই দিক (সত্য আর মিথ্যা) দুটোই যাচাই করতে হবে।
Action-গুলোও লিখে রাখুন, কারণ অনেক defect state-এ নয়, action-এ থাকে: T1-এ টাকা কাটা একবার; T6 আর T7-এ “refund বাকি” চিহ্ন বসানো আর স্টক ফেরত; T3-এ ক্রেতাকে SMS; T8-এ টাকা ফেরত। একটি test যদি শুধু দেখে “state এখন Paid”, কিন্তু দুবার টাকা কাটা হলো কি না না দেখে, তবে সেটি অর্ধেক কাজ করল।
৩ · State table — ছবিতে যা আঁকা থাকে না
State diagram শুধু বৈধ পথ আঁকে। কিন্তু ব্যবহারকারী ভুল সময়ে ভুল বোতামও চাপেন: পৌঁছে যাওয়া অর্ডারে “বাতিল”, দুবার “টাকা দিন”, প্যাকের আগেই “কুরিয়ারে দিন”। এসব ক্ষেত্রে কী হওয়া উচিত, ছবি নীরব। State table এই নীরবতা ভাঙে: প্রতিটি state একটি সারি, প্রতিটি event একটি কলাম, আর প্রতিটি ঘরে লেখা থাকে নতুন state, অথবা ✗ (অবৈধ)। ৭টি state × ৬টি event = ৪২টি ঘর, আর প্রতিটি ঘর একটি প্রশ্ন।
| state | |
| pay | |
| pack | |
| ship | |
| deliver | |
| cancel | |
| refund | |
| বৈধ / অবৈধ (মোট) |
- Placed-এর সারি। নতুন অর্ডারে শুধু দুটি event-এর পথ আছে: pay (T1) আর cancel (T5). বাকি চারটি ✗: টাকা ছাড়া প্যাক, শিপ, ডেলিভারি বা refund হয় না। চলমান মোট: ২টি বৈধ, ৪টি অবৈধ।
- Paid-এর সারি। pack (T2) আর cancel (T6) বৈধ। লক্ষ করুন pay-এর ঘর ✗: দ্বিতীয়বার টাকা নেওয়া চলবে না। এই একটি ঘর থেকেই “দুবার টাকা কাটা” test-এর জন্ম। মোট ৪ / ৮।
- Packed-এর সারি। ship (T3) আর cancel (T7) বৈধ, বাকি চারটি ✗। মোট ৬ / ১২।
- Shipped-এর সারি। শুধু deliver (T4). cancel-এর ঘর এখানে ✗, কারণ requirement বলে Shipped-এর আগেই বাতিল করা যায়। এটিই সেই ঘর, যা ভুল কোডে খোলা থাকলে ছবির লাল তীর তৈরি হয়। মোট ৭ / ১৭।
- Delivered-এর সারি। শেষ অবস্থা, ছয়টি ঘরই ✗। একটি প্রশ্ন জাগে: পণ্য ফেরত (return) দেওয়া যায় কি? Requirement-এ নেই। এমন ফাঁক product owner-কে জিজ্ঞেস করতে হয়। মোট ৭ / ২৩।
- Cancelled-এর সারি। শুধু refund-এর ঘরে পথ আছে, তা-ও guard
[paid]সত্য হলে (T8). একটি ঘরের ভেতরে দুটি test লুকিয়ে: টাকা দেওয়া অর্ডারে refund সফল, টাকা না দেওয়া অর্ডারে প্রত্যাখ্যান। মোট ৮ / ২৮। - Refunded-এর সারি, আর হিসাব। শেষ অবস্থা, ছয়টি ✗। মোট ৪২টি ঘর: ৮টি বৈধ, ৩৪টি অবৈধ। ছবিতে ৮টি তীর দেখেছিলেন; টেবিল দেখাল আরও ৩৪টি প্রশ্ন, যার প্রতিটির প্রত্যাশিত ফল requirement থেকে ঠিক করতে হবে।
পুরো টেবিলটি একসাথে (✗ মানে অবৈধ, প্রত্যাশিত ফল: প্রত্যাখ্যান, state অপরিবর্তিত):
| State \ Event | pay | pack | ship | deliver | cancel | refund |
|---|---|---|---|---|---|---|
| Placed | Paid / টাকা কাটা (T1) | ✗ | ✗ | ✗ | Cancelled (T5) | ✗ |
| Paid | ✗ | Packed (T2) | ✗ | ✗ | Cancelled / refund বাকি (T6) | ✗ |
| Packed | ✗ | ✗ | Shipped / SMS (T3) | ✗ | Cancelled / refund বাকি (T7) | ✗ |
| Shipped | ✗ | ✗ | ✗ | Delivered (T4) | ✗ | ✗ |
| Delivered | ✗ | ✗ | ✗ | ✗ | ✗ | ✗ |
| Cancelled | ✗ | ✗ | ✗ | ✗ | ✗ | [paid] Refunded / টাকা ফেরত (T8) |
| Refunded | ✗ | ✗ | ✗ | ✗ | ✗ | ✗ |
State table-এর আসল শক্তি test-এর আগেই কাজ করে: এটি requirement-এর static testing-এর হাতিয়ার। ঘর ধরে ধরে পড়লে কয়েকটি প্রশ্ন উঠে আসে, যা লিখিত নিয়মে নেই:
- সময়ের event: Placed অবস্থায় টাকা না দিয়ে অর্ডার কতক্ষণ পড়ে থাকবে? অনেক দোকানে নির্দিষ্ট সময় পরে নিজে থেকে বাতিল হয়; সেটি হলে একটি নতুন event (
timeout) আর নতুন কলাম লাগবে। - ব্যর্থ ঘটনা: payment ব্যর্থ হলে state কী? কুরিয়ার পৌঁছাতে না পারলে?
- শেষ অবস্থার পরে: Delivered-এর পরে পণ্য ফেরত বা অভিযোগ; Refunded-এর পরে আবার অর্ডার করা নতুন অর্ডার, না পুরোনোটি?
- অবৈধ ঘরের আচরণ: “✗” মানে কি বোতামটি লুকানো, ধূসর, নাকি চাপলে বার্তা? API-তে কোন HTTP status? প্রত্যাশিত ফল না জানলে test-এর oracle নেই।
৪ · Coverage-এর চারটি মাপ
মডেল হাতে এলে প্রশ্ন: কতটা test যথেষ্ট? এখানে প্রতিটি মাপের একটি coverage item থাকে, অর্থাৎ যে জিনিসগুলো গোনা হয়, আর coverage % = ঢাকা item ÷ মোট item × ১০০। ISTQB-এর বর্তমান Foundation syllabus (আমাদের জানামতে v4.0) তিনটি মাপ বলে; চতুর্থটি (1-switch) পুরোনো syllabus আর উন্নত স্তরে বহুল ব্যবহৃত:
| মাপ | Coverage item | বাজারঘরে মোট | কী ধরে, কী ধরে না |
|---|---|---|---|
| All states | প্রতিটি state অন্তত একবার পৌঁছানো | ৭ | সবচেয়ে দুর্বল; একটি transition বাদ পড়লেও ১০০% হতে পারে |
| Valid transitions (0-switch) | প্রতিটি বৈধ transition অন্তত একবার | ৮ | বৈধ পথের ভুল ধরে; খোলা থাকা অবৈধ পথ ধরে না |
| 1-switch | পরপর দুটি বৈধ transition-এর প্রতিটি সম্ভব জোড়া | ৭ | আগের ধাপের ওপর নির্ভর করা ভুল ধরে |
| All transitions | State table-এর প্রতিটি ঘর: বৈধ transition চালানো, অবৈধ event চেষ্টা করা | ৪২ | অবৈধ পথ খোলা থাকার defect ধরে; সংখ্যায় সবচেয়ে বেশি |
“0-switch” নামটির অর্থ: transition-এর মাঝে শূন্যটি “বদল” (switch). 1-switch মানে দুটি পরপর transition, যার মাঝে একটি state পেরোনো; N-switch মানে N+1টি পরপর transition. এই নামকরণ সাধারণত T. S. Chow-এর ১৯৭৮ সালের state machine testing-এর গবেষণার সাথে যুক্ত করা হয়। একটি গুরুত্বপূর্ণ সম্পর্ক: সব বৈধ transition ঢাকলে সব পৌঁছানো যায় এমন state-ও ঢাকা হয়ে যায়, তাই 0-switch সাধারণত all states-এর চেয়ে শক্তিশালী।
এবার একটি sequence ধরে হাঁটুন। প্রতিটি ধাপে state, লুকানো paid তথ্য আর চারটি coverage গণনা কীভাবে বদলায়, দেখুন:
0new order1pay2pack3cancel4refund5refund
| state | |
| paid | |
| এই ধাপ | |
| 0-switch | |
| 1-switch | |
| all trans. |
- শুরু। নতুন অর্ডার, state Placed, টাকা দেওয়া হয়নি (
paidFalse). শুরুর state পৌঁছানো হলেও কোনো transition এখনো চলেনি, তাই সব গণনা শূন্য। - pay. Placed + pay = T1. State Paid,
paidএখন True. 0-switch ১/৮; all transitions-এর ৪২টি ঘরের একটি ঢাকা হলো। - pack. Paid + pack = T2, state Packed. প্রথমবার দুটি transition পরপর: জোড়া T1→T2, তাই 1-switch ১/৭।
- cancel. Packed + cancel = T7, state Cancelled; action হিসেবে “refund বাকি”। নতুন জোড়া T2→T7, 1-switch ২/৭।
- refund. Cancelled + refund, guard
[paid]সত্য, তাই T8; state Refunded. জোড়া T7→T8 ঢাকা হলো, ৩/৭। এই জোড়াটি পরে একটি লুকানো defect ধরবে। - আবার refund. Refunded + refund = ✗. প্রত্যাশিত ফল: প্রত্যাখ্যান (এখানে
ValueError), state Refunded-ই থাকে, আর দ্বিতীয়বার টাকা ফেরত হয় না। বৈধ coverage বাড়ে না, কিন্তু all transitions-এর একটি অবৈধ ঘর ঢাকা হলো: ৫/৪২। অবৈধ event রাখা হয়েছে sequence-এর শেষে, একটিমাত্র; কেন, §৬-এ দেখবেন।
1-switch জোড়া গোনা — একটি সহজ সূত্র
1-switch-এর item হলো এমন জোড়া (Ta, Tb), যেখানে Ta যে state-এ শেষ হয়, Tb সেখান থেকে শুরু হয়। প্রতিটি state-এ যতগুলো তীর ঢোকে (in-degree) আর যতগুলো বের হয় (out-degree), তাদের গুণফলই সেই state দিয়ে যাওয়া জোড়ার সংখ্যা। সব state-এর গুণফল যোগ করলে মোট জোড়া। তারপর guard-এর কারণে যে জোড়া বাস্তবে চালানো অসম্ভব, সেগুলো বাদ দিন।
| transition | |
| শেষ হয় | |
| এরপর আসতে পারে | |
| নতুন জোড়া | |
| মোট |
- T1 (pay). শেষ হয় Paid-এ। Paid থেকে বের হয় T2 আর T6, তাই দুটি জোড়া: T1→T2, T1→T6. মোট ২।
- T2 (pack). Packed-এ শেষ; সেখান থেকে T3 আর T7. আরও দুটি, মোট ৪।
- T3 (ship). Shipped-এ শেষ; সেখান থেকে শুধু T4. মোট ৫।
- T4 (deliver). Delivered শেষ অবস্থা, কোনো তীর বের হয় না। নতুন জোড়া নেই, মোট ৫।
- T5 (অপরিশোধিত বাতিল). Cancelled-এ শেষ, সেখান থেকে T8 বের হয়। কাঠামো দেখলে T5→T8 একটি জোড়া। কিন্তু T5 শুধু Placed থেকে আসে, যেখানে টাকা দেওয়া হয়নি, তাই guard
[paid]মিথ্যা: এই জোড়া চালানো অসম্ভব। গোনা হবে না, মোট ৫ থাকে। (এর উল্টো দিকটি, “অপরিশোধিত বাতিলের পরে refund প্রত্যাখ্যাত হয় কি না”, একটি negative test হিসেবে আলাদা রাখা হবে।) - T6 (পরিশোধিত বাতিল). Paid থেকে আসে, টাকা দেওয়া, তাই T6→T8 সম্ভব। মোট ৬।
- T7 (প্যাকের পরে বাতিল). একইভাবে T7→T8 সম্ভব। মোট ৭।
- T8, আর সূত্র দিয়ে যাচাই। Refunded শেষ অবস্থা, জোড়া নেই। সূত্র: Paid ১×২ + Packed ১×২ + Shipped ১×১ + Cancelled ৩×১ = ৮টি কাঠামোগত জোড়া; guard-এর কারণে T5→T8 বাদ, তাই ৭টি সম্ভব জোড়া।
৫ · ধাপে ধাপে test নকশা
পুরো পদ্ধতিটি একটি তালিকায়। Manual tester আর automation engineer দুজনের জন্যই একই ধাপ; পার্থক্য শুধু শেষে test কাগজে লিখবেন না কোডে।
- Requirement থেকে state আর event তালিকা। বিশেষ্য খুঁজুন যা “অবস্থা” বোঝায় (Paid, Shipped), আর ক্রিয়া যা বাইরে থেকে আসে (pay, cancel). সময় আর ব্যর্থতাকেও event ভাবুন।
- State diagram আঁকুন, প্রতিটি তীরে
event [guard] / actionলিখে T1, T2… নাম দিন। - State table বানান, সব ঘর পূরণ করুন, আর প্রতিটি “জানি না” ঘর নিয়ে product owner-কে প্রশ্ন করুন।
- Coverage লক্ষ্য বাছুন ঝুঁকি দেখে: সাধারণত 0-switch আর সব অবৈধ ঘর; টাকার পথে 1-switch.
- Test sequence বানান: শুরুর state থেকে এমন পথ, যাতে অল্প কয়েকটি sequence-এ সব item ঢাকা পড়ে। অবৈধ ঘরের জন্য সেই state-এ পৌঁছানোর ছোট পথ, তারপর একটিমাত্র অবৈধ event.
- প্রতিটি ধাপের প্রত্যাশিত ফল লিখুন: নতুন state, action (টাকা, SMS, স্টক), আর অবৈধ event-এ “প্রত্যাখ্যান, state অপরিবর্তিত, কোনো action নয়”।
- চালান, coverage মাপুন, আর না ঢাকা item থাকলে নতুন sequence যোগ করুন।
এই পদ্ধতিতে বাজারঘরের জন্য একটি test case তালিকা (প্রথম চারটি 0-switch আর 1-switch-এর জন্য, বাকিগুলো অবৈধ ঘর আর guard-এর নমুনা):
| ID | শুরু / event-এর ক্রম | প্রত্যাশিত ফল | Coverage item |
|---|---|---|---|
| ST-01 | Placed: pay, pack, ship, deliver | Delivered; টাকা একবার কাটা; SMS একবার | T1 T2 T3 T4; জোড়া T1T2, T2T3, T3T4 |
| ST-02 | Placed: cancel | Cancelled; refund বাকি নয় | T5 |
| ST-03 | Placed: pay, cancel, refund | Refunded; টাকা ফেরত | T1 T6 T8; জোড়া T1T6, T6T8 |
| ST-04 | Placed: pay, pack, cancel, refund | Refunded; টাকা ফেরত | T1 T2 T7 T8; জোড়া T2T7, T7T8 |
| ST-05 | Shipped (pay, pack, ship), তারপর cancel | প্রত্যাখ্যান; state Shipped | অবৈধ ঘর (Shipped, cancel) |
| ST-06 | Paid (pay), তারপর pay | প্রত্যাখ্যান; state Paid; টাকা আর কাটা হয় না | অবৈধ ঘর (Paid, pay) |
| ST-07 | Cancelled, অপরিশোধিত (cancel), তারপর refund | প্রত্যাখ্যান; state Cancelled | guard [paid] মিথ্যা |
| ST-08 … | বাকি ৩২টি অবৈধ ঘর, একইভাবে | প্রত্যাখ্যান; state অপরিবর্তিত | অবৈধ ঘর |
প্রথম চারটি test-এ ৮টি বৈধ transition আর ৭টি জোড়াই ঢাকা পড়ে। হাতে এমন সেট বানানো সম্ভব, কিন্তু বড় মডেলে ভুল হয়। নিচের কোড মডেলটিকে data হিসেবে রাখে, প্রতিটি item-এর জন্য সবচেয়ে ছোট সম্ভব পথ খোঁজে (guard মেনে), আর অন্য পথের শুরুর অংশ হয়ে যাওয়া পথগুলো বাদ দেয়। “চালান” চাপুন; প্রথমবার ব্রাউজারে Python (Pyodide) নামতে কয়েক সেকেন্ড লাগে।
# Order status machine as data: id -> (from, event, to)
T = {"T1": ("Placed", "pay", "Paid"), "T2": ("Paid", "pack", "Packed"),
"T3": ("Packed", "ship", "Shipped"),
"T4": ("Shipped", "deliver", "Delivered"),
"T5": ("Placed", "cancel", "Cancelled"),
"T6": ("Paid", "cancel", "Cancelled"),
"T7": ("Packed", "cancel", "Cancelled"),
"T8": ("Cancelled", "refund", "Refunded")} # guard: [paid]
cells = 7 * 6 # 7 states x 6 events
print(f"state table: {cells} cells, {len(T)} valid, {cells - len(T)} invalid")
def ok(seq): # can this transition sequence really run?
st, paid = "Placed", False
for t in seq:
src, ev, dst = T[t]
if src != st or (t == "T8" and not paid): return False
st, paid = dst, paid or ev == "pay"
return True
def path_to(goal): # shortest feasible test that fires `goal`
frontier = [[]]
while frontier:
seq = frontier.pop(0)
if ok(seq + goal): return " ".join(seq + goal)
frontier += [seq + [t] for t in T if ok(seq + [t])]
pairs = [[a, b] for a in T for b in T if path_to([a, b])]
print("feasible 1-switch pairs:", len(pairs))
for name, items in (("0-switch", [[t] for t in T]),
("0+1-switch", [[t] for t in T] + pairs)):
paths = list(dict.fromkeys(path_to(it) for it in items))
tests = [p for p in paths if not any(q != p and q.startswith(p + " ")
for q in paths)]
n = sum(len(p.split()) for p in tests)
print(f"{name}: {len(tests)} tests, {n} events:", " | ".join(tests))আসল আউটপুট (ব্রাউজারের Python):
state table: 42 cells, 8 valid, 34 invalid
feasible 1-switch pairs: 7
0-switch: 4 tests, 11 events: T1 T2 T3 T4 | T5 | T1 T2 T7 | T1 T6 T8
0+1-switch: 4 tests, 12 events: T1 T2 T3 T4 | T5 | T1 T6 T8 | T1 T2 T7 T8
ok() একটি transition-এর ক্রম সত্যিই চালানো যায় কি না দেখে: প্রতিটি transition আগেরটির শেষ state থেকে শুরু হতে হবে, আর T8-এর আগে টাকা দেওয়া থাকতে হবে। path_to() breadth-first search: ছোট পথ আগে, তাই প্রতিটি item-এর জন্য সবচেয়ে ছোট test পাওয়া যায়। Stepper-এর হিসাবই মিলল: ৩৪টি অবৈধ ঘর আর ৭টি সম্ভব জোড়া (T5→T8 guard-এর কারণে বাদ)। মজার ব্যাপার, 0-switch-এর জন্য ৪টি test (১১টি event) লাগে, আর 1-switch যোগ করতেও ৪টিই (১২টি event): শুধু T1 T2 T7-এর শেষে একটি refund জুড়লেই T7→T8 জোড়া ঢাকা পড়ে। এই একটি বাড়তি event-এর দাম কত, §৭-এ দেখবেন। আরও লক্ষ করুন, T5 কোনো সম্ভব জোড়ায় নেই, তাই শুধু জোড়া গুনলে T5 বাদ পড়ত; এ জন্যই কোড দুটি তালিকা একসাথে নেয়।
৬ · Seeded defect ১ — শিপ হওয়ার পরে বাতিল
এবার মডেল থেকে আসল test, আর একটি বাস্তব কোডে। Developer অর্ডারের নিয়ম একটি dictionary-তে লিখেছেন; তাতে ইচ্ছা করে একটি seeded defect রাখা হয়েছে: Shipped অবস্থায় cancel-এর একটি বাড়তি সারি। Test-গুলো লেখা হয়েছে requirement থেকে (প্রতিটি state-এ কোন event বৈধ), developer-এর dictionary থেকে নয়। এক test method-এর ভেতরে subTest দিয়ে ৩৪টি অবৈধ ঘরের প্রতিটি আলাদাভাবে যাচাই হয়।
import sys, unittest
NEXT = {("Placed", "pay"): "Paid", ("Paid", "pack"): "Packed", # developer's
("Packed", "ship"): "Shipped", ("Shipped", "deliver"): "Delivered",
("Placed", "cancel"): "Cancelled", ("Paid", "cancel"): "Cancelled",
("Packed", "cancel"): "Cancelled", ("Shipped", "cancel"): "Cancelled",
("Cancelled", "refund"): "Refunded"} # table
class Order: # code under test
def __init__(self): self.state, self.paid = "Placed", False
def handle(self, ev):
key = (self.state, ev)
if key not in NEXT or (ev == "refund" and not self.paid):
raise ValueError(f"{ev} not allowed in {self.state}")
self.state, self.paid = NEXT[key], self.paid or ev == "pay"
# Tests come from the REQUIREMENT: allowed events per state, and a way in
ALLOWED = {"Placed": "pay cancel", "Paid": "pack cancel", "Packed":
"ship cancel", "Shipped": "deliver", "Delivered": "",
"Cancelled": "refund", "Refunded": ""}
REACH = {"Placed": "", "Paid": "pay", "Packed": "pay pack",
"Shipped": "pay pack ship", "Delivered": "pay pack ship deliver",
"Cancelled": "pay cancel", "Refunded": "pay cancel refund"}
class InvalidTransitions(unittest.TestCase):
def test_every_invalid_cell(self): # 34 sub-tests
for s in REACH:
for ev in "pay pack ship deliver cancel refund".split():
if ev in ALLOWED[s].split(): continue
with self.subTest(state=s, event=ev):
o = Order()
for e in REACH[s].split(): o.handle(e)
self.assertRaises(ValueError, o.handle, ev)
self.assertEqual(o.state, s) # state unchanged
unittest.TextTestRunner(stream=sys.stdout, verbosity=2).run(
unittest.TestLoader().loadTestsFromTestCase(InvalidTransitions))আসল আউটপুট (ব্রাউজারের Python, traceback ছাঁটা):
test_every_invalid_cell (__main__.InvalidTransitions.test_every_invalid_cell) ...
test_every_invalid_cell (__main__.InvalidTransitions.test_every_invalid_cell) (state='Shipped', event='cancel') ... FAIL
FAIL: test_every_invalid_cell (__main__.InvalidTransitions.test_every_invalid_cell) (state='Shipped', event='cancel')
…
AssertionError: ValueError not raised by handle
Ran 1 test in 0.001s
FAILED (failures=1)
৩৪টি sub-test-এর ৩৩টি পাস, শুধু একটি fail, আর বার্তা ঠিক কোন ঘরে সমস্যা তা বলে দেয়: state='Shipped', event='cancel'. কোড অবৈধ event-এ ValueError তোলার কথা; এখানে তোলেনি, কারণ dictionary-তে বাড়তি সারি আছে। বাস্তবে এর মানে: কুরিয়ারের হাতে থাকা পণ্যের অর্ডার বাতিল হয়ে যাচ্ছে, অথচ পণ্য ক্রেতার দরজায় পৌঁছাবে। লক্ষ করুন, ৮টি বৈধ transition-এর সব test এই কোডে পাস করত; 0-switch ১০০% হলেও defect-টি অদৃশ্য থাকত। subTest থাকায় প্রথম fail-এর পরেও বাকি ঘরগুলো চলেছে; তাই একবারে সব ভাঙা ঘর দেখা যায়। “Ran 1 test” লেখা, কারণ unittest পুরো method-কে একটি test গোনে।
কেন প্রতিটি test-এ একটিমাত্র অবৈধ event
ধরুন সময় বাঁচাতে একটি test-এ পরপর তিনটি অবৈধ event পাঠালেন: Shipped-এ cancel, তারপর pay, তারপর pack, আর শেষে দেখলেন state Shipped আছে কি না। ভুল কোডে প্রথম event অর্ডারকে Cancelled-এ নিয়ে গেল; পরের দুটি event Cancelled-এ অবৈধ, তাই প্রত্যাখ্যাত; শেষে state Cancelled, test fail. এ পর্যন্ত ঠিক। কিন্তু এখন উল্টোটা ভাবুন: দুটি ভুল একে অপরকে ঢেকে দিতে পারে। এক অবৈধ event state বদলে দিল, পরের অবৈধ event কাকতালীয়ভাবে আগের state-এ ফিরিয়ে আনল, আর শেষের যাচাই সবুজ। একে বলে fault masking. তাই ISTQB-এর syllabus পরামর্শ দেয়: অবৈধ transition একটি test-এ একটি করে। আরেকটি কারণ ব্যবহারিক: অনেক system অবৈধ event পেলে session বন্ধ করে বা error পাতায় নিয়ে যায়, তাই পরের event আর আসল অবস্থায় পৌঁছায়ই না।
৭ · Seeded defect ২ — জোড়ায় লুকানো bug, আর coverage মাপা
এবার এমন একটি defect, যা কোনো একক transition-এ নেই, আছে দুটি transition-এর সংযোগে। Developer-এর ধারণা ছিল “টাকা দেওয়া অর্ডার বাতিল হলে refund বাকি”, কিন্তু কোডে লিখেছেন শুধু Paid থেকে বাতিলের কথা; Packed থেকে বাতিলের সময় refund-এর চিহ্ন বসে না। নিচে একই কোডে দুটি suite: 0-switch-এর চারটি test, আর তার সাথে 1-switch-এর বাড়তি একটি test.
import sys, unittest
class Order: # code under test, another seeded defect
NEXT = {("Placed", "pay"): "Paid", ("Paid", "pack"): "Packed",
("Packed", "ship"): "Shipped", ("Shipped", "deliver"): "Delivered",
("Placed", "cancel"): "Cancelled", ("Paid", "cancel"): "Cancelled",
("Packed", "cancel"): "Cancelled"}
def __init__(self): self.state, self.refund_due = "Placed", False
def handle(self, ev):
s = self.state
if ev == "refund" and s == "Cancelled" and self.refund_due:
self.state = "Refunded"; return
if (s, ev) not in self.NEXT: raise ValueError(f"{ev} not allowed in {s}")
if ev == "cancel": self.refund_due = (s == "Paid") # Packed forgotten
self.state = self.NEXT[(s, ev)]
def run(events):
o = Order()
for ev in events.split(): o.handle(ev)
return o.state
class ZeroSwitch(unittest.TestCase): # every valid transition once
def test_s1_full_journey(self):
self.assertEqual(run("pay pack ship deliver"), "Delivered")
def test_s2_cancel_unpaid(self): self.assertEqual(run("cancel"), "Cancelled")
def test_s3_cancel_paid_refund(self):
self.assertEqual(run("pay cancel refund"), "Refunded")
def test_s4_cancel_packed(self):
self.assertEqual(run("pay pack cancel"), "Cancelled")
class OneSwitch(ZeroSwitch): # adds the missing pair T7 -> T8
def test_s5_cancel_packed_refund(self):
self.assertEqual(run("pay pack cancel refund"), "Refunded")
for case in (ZeroSwitch, OneSwitch):
print(f"=== {case.__name__}")
unittest.TextTestRunner(stream=sys.stdout, verbosity=1).run(
unittest.TestLoader().loadTestsFromTestCase(case))আসল আউটপুট (ব্রাউজারের Python, traceback ছাঁটা):
=== ZeroSwitch
....
Ran 4 tests in 0.000s
OK
=== OneSwitch
....E
ERROR: test_s5_cancel_packed_refund (__main__.OneSwitch.test_s5_cancel_packed_refund)
…
ValueError: refund not allowed in Cancelled
Ran 5 tests in 0.001s
FAILED (errors=1)
0-switch suite পুরো সবুজ, অথচ ৮টি বৈধ transition-ই সেখানে চলেছে: T7 চলেছে test_s4-এ, T8 চলেছে test_s3-এ। কিন্তু T7-এর পরে T8 কেউ চালায়নি। 1-switch-এর বাড়তি test ঠিক সেই জোড়া চালাল, আর ধরা পড়ল: প্যাকের পরে বাতিল করা ক্রেতা টাকা ফেরত পাচ্ছেন না। এখানে ফল E (ERROR), F (FAIL) নয়: unittest-এ FAIL মানে কোনো assertion মেলেনি, আর ERROR মানে test চলার সময় অপ্রত্যাশিত exception উঠেছে; দুটিই লাল। OneSwitch class ZeroSwitch-এর চারটি test উত্তরাধিকারে পায়, তাই দ্বিতীয় run-এ ৫টি test.
শেষে একটি coverage মাপার যন্ত্র। এটি কোনো test suite-কে event-এর ক্রম হিসেবে নেয়, মডেলের ওপর চালায়, আর চারটি মাপ শতাংশে ছাপে। তিনটি suite তুলনা করা হলো: শুধু happy path, 0-switch সেট, আর 1-switch সেট সাথে ৩৪টি অবৈধ-ঘরের test. (সরলতার জন্য এই মাপযন্ত্র guard দেখে না।)
SPEC = {("Placed", "pay"): "Paid", ("Paid", "pack"): "Packed",
("Packed", "ship"): "Shipped", ("Shipped", "deliver"): "Delivered",
("Placed", "cancel"): "Cancelled", ("Paid", "cancel"): "Cancelled",
("Packed", "cancel"): "Cancelled", ("Cancelled", "refund"): "Refunded"}
STATES = {"Placed", "Paid", "Packed", "Shipped", "Delivered",
"Cancelled", "Refunded"}
EVENTS = "pay pack ship deliver cancel refund".split()
PAIRS = 7 # feasible 1-switch pairs (counted earlier)
def measure(name, tests):
states, valid, invalid, pairs = {"Placed"}, set(), set(), set()
for test in tests:
st, last = "Placed", None
for ev in test.split():
if (st, ev) not in SPEC: # invalid attempt: record, stop
invalid.add((st, ev)); break
if last: pairs.add((last, (st, ev)))
last, st = (st, ev), SPEC[(st, ev)]
valid.add(last); states.add(st)
pct = lambda a, b: f"{len(a)}/{b} = {len(a) / b:.1%}"
print(f"{name}\n all states {pct(states, len(STATES))}"
f"\n 0-switch {pct(valid, len(SPEC))}"
f"\n 1-switch {pct(pairs, PAIRS)}"
f"\n all transit. {pct(valid | invalid, len(STATES) * len(EVENTS))}")
happy = ["pay pack ship deliver"]
zero = happy + ["cancel", "pay cancel refund", "pay pack cancel"]
one = zero[:3] + ["pay pack cancel refund"]
reach = {"Placed": "", "Paid": "pay ", "Packed": "pay pack ",
"Shipped": "pay pack ship ", "Delivered": "pay pack ship deliver ",
"Cancelled": "pay cancel ", "Refunded": "pay cancel refund "}
bad = [reach[s] + e for s in STATES for e in EVENTS if (s, e) not in SPEC]
for name, suite in (("happy path", happy), ("0-switch set", zero),
("1-switch set + 34 invalid", one + bad)):
measure(name, suite)আসল আউটপুট (ব্রাউজারের Python):
happy path
all states 5/7 = 71.4%
0-switch 4/8 = 50.0%
1-switch 3/7 = 42.9%
all transit. 4/42 = 9.5%
0-switch set
all states 7/7 = 100.0%
0-switch 8/8 = 100.0%
1-switch 6/7 = 85.7%
all transit. 8/42 = 19.0%
1-switch set + 34 invalid
all states 7/7 = 100.0%
0-switch 8/8 = 100.0%
1-switch 7/7 = 100.0%
all transit. 42/42 = 100.0%
Happy path-এর একটি test ৭টির ৫টি state ছোঁয় (৭১.৪%), কিন্তু ৪২টি ঘরের মাত্র ৪টি (৯.৫%). 0-switch সেট বৈধ পথে ১০০%, তবু 1-switch ৮৫.৭% (৬/৭; বাদ পড়া জোড়াটিই T7→T8, যেখানে defect ২ লুকিয়ে ছিল) আর all transitions মাত্র ১৯.০% (৮/৪২; যেখানে defect ১ লুকিয়ে ছিল)। শেষ সেট চারটি মাপেই ১০০%. একটি মাপের ১০০% অন্য মাপ সম্পর্কে কিছু বলে না; রিপোর্টে সবসময় লিখুন কোন মাপের coverage.
৮ · ফাঁদ, বাস্তবতা আর tool
সাধারণ ভুলগুলো: (১) শুধু বৈধ পথ test করা, অবৈধ ঘর ভুলে যাওয়া; (২) অবৈধ event-এর পরে state অপরিবর্তিত কি না যাচাই না করা, শুধু “error এসেছে” দেখা; (৩) guard-এর শুধু সত্য দিক test করা; (৪) action যাচাই না করা (দুবার টাকা কাটা, SMS না যাওয়া); (৫) মডেল কোড দেখে বানানো, requirement থেকে নয়; তখন মডেল আর কোড একই ভুল ভাগ করে।
State explosion: বাস্তব system-এ অবস্থা কয়েকটি variable-এর মিশ্রণ। অর্ডারের status-এর সাথে payment পদ্ধতি (cash, mobile wallet, card), delivery slot আর coupon মেলালে state-এর সংখ্যা গুণ হয়ে বাড়ে, আর 1-switch-এর জোড়া আরও দ্রুত। প্রতিকার: প্রতিটি মডেল একটি প্রশ্নের জন্য ছোট রাখা (order status একটি মডেল, payment-এর ধাপ আরেকটি), state-কে আচরণের ভিত্তিতে দলবদ্ধ করা (পর্ব ০৭-এর partition-এর ধারণা), আর গভীর coverage শুধু ঝুঁকিপূর্ণ অংশে।
লুকানো state: UI-তে যা দেখা যায় না, এমন তথ্যও state-এর অংশ: paid, ভুল OTP-এর গণনা, cart-এ কয়টি পণ্য। মডেলে এগুলো না রাখলে test-ও এগুলো ছোঁবে না।
সময় আর একসাথে আসা event: “৩০ মিনিটে টাকা না দিলে বাতিল” জাতীয় নিয়মে event-টি হলো সময়। Test-এ আসল ৩০ মিনিট অপেক্ষা না করে ঘড়িকে নিয়ন্ত্রণযোগ্য করতে হয় (পর্ব ২৫-এ testable design). আর ক্রেতা যখন “বাতিল” চাপছেন ঠিক তখন গুদাম “শিপ” করলে কোনটি জিতবে? এমন race condition state machine-এর ছবিতে দেখা যায় না; পর্ব ৬২-এ concurrency testing আর পর্ব ৭০-এ event-driven system-এর idempotency দেখবেন।
কোথায় test করবেন: একই মডেল তিন স্তরে কাজে লাগে। Unit স্তরে state machine-এর class (যেমন ওপরের কোড); API স্তরে POST /orders/7/cancel-এর মতো অনুরোধ, যেখানে অবৈধ ঘরে নির্দিষ্ট error code প্রত্যাশিত (পর্ব ৩১); আর UI স্তরে বোতাম লুকানো বা নিষ্ক্রিয় কি না। মনে রাখুন, UI-তে বোতাম লুকানো থাকলেও API সরাসরি ডাকা যায়, তাই অবৈধ ঘরের আসল পাহারা থাকতে হবে server-এ।
Tool: বড় মডেল থেকে test নিজে থেকে বানানোর ধারাকে বলে model-based testing; GraphWalker-এর মতো open-source tool একটি graph মডেল থেকে পথ তৈরি করে। Python-এ Hypothesis library-র stateful testing (RuleBasedStateMachine) এলোমেলো event-এর ক্রম বানিয়ে invariant যাচাই করে; পর্ব ৫৮-এ property-based testing-এ এটি দেখবেন। আর কোন seeded defect আপনার suite ধরে, তার পদ্ধতিগত রূপ mutation testing, পর্ব ৫৯-এ।
আরও গভীরে: Finite state machine থেকে test বানানোর গবেষণা পুরোনো। T. S. Chow-এর ১৯৭৮ সালের IEEE Transactions on Software Engineering-এর প্রবন্ধ (W-method নামে পরিচিত পদ্ধতি) দেখায়, কিছু শর্তে (যেমন implementation-এ state-এর সংখ্যা একটি সীমার মধ্যে) একটি সসীম test সেট দিয়েই নির্দিষ্ট ধরনের সব ভুল ধরা সম্ভব। পরে এ নিয়ে বিশাল গবেষণা হয়েছে, যেমন transition tour আর distinguishing sequence. ISO/IEC/IEEE 29119-4 state transition testing-কে একটি মানক কৌশল হিসেবে বর্ণনা করে। Trade-off: তাত্ত্বিক নিশ্চয়তা আসে কঠোর অনুমান থেকে; বাস্তবের extended state machine, সময় আর concurrency সেই অনুমান প্রায়ই ভাঙে।
পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এমন প্রশ্ন খুব চেনা:
- ৫টি state, ৪টি event, ৭টি বৈধ transition; অবৈধ ঘর কয়টি? — ৫ × ৪ − ৭ = ১৩.
- 0-switch আর 1-switch-এর পার্থক্য? — 0-switch: প্রতিটি বৈধ transition একবার; 1-switch: পরপর দুটি transition-এর প্রতিটি সম্ভব জোড়া।
- 1-switch জোড়া গোনার দ্রুত উপায়? — প্রতিটি state-এ (ঢোকা তীর × বের হওয়া তীর)-এর যোগফল, তারপর guard-এ অসম্ভব জোড়া বাদ।
- অবৈধ transition-এর প্রত্যাশিত ফল কী লিখবেন? — প্রত্যাখ্যান, state অপরিবর্তিত, কোনো action নয়; প্রতি test-এ একটি।
- কোন coverage “শিপের পরে বাতিল” ধরে? — All transitions (অবৈধ ঘরসহ); শুধু 0-switch ধরে না।
৯ · AI-এর যুগে state transition testing
AI assistant-কে “order status-এর test লিখে দিন” বললে সাধারণত যা আসে: একটি happy path (pay, pack, ship, deliver), হয়তো একটি বাতিল, আর সব সবুজ। অবৈধ ঘর প্রায় থাকে না। আরও বিপজ্জনক, AI প্রায়ই কোড পড়ে কোডের dictionary থেকেই প্রত্যাশিত ফল বানায়; তখন §৬-এর বাড়তি সারি (Shipped-এ cancel) test-এ “বৈধ” হিসেবে ঢুকে যায়, আর ভুল কোডেই test পাস করে। AI নিজে থেকে guard-এর মিথ্যা দিক, action-এর যাচাই বা 1-switch জোড়া খুব কমই ধরে; অপেক্ষার জন্য sleep বসাতে পারে; framework-এর এমন option লিখতে পারে যা নেই; আর না চালিয়েই বলতে পারে “all tests pass”.
AI-কে কোড নয়, requirement আর মডেল দিন, আর কাজ ভাগ করে চান:
AI-লেখা state test হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১State machine ধারণাটি কোথা থেকে এলো, আর ১৯৫০-এর দশকের একটি গাণিতিক মডেল আজকের অনলাইন দোকানের test-এ কেন এত কাজের?
সসীম অবস্থার যন্ত্রের ধারণা গড়ে ওঠে ১৯৫০-এর দশকে, মূলত switching circuit আর স্বয়ংক্রিয় যন্ত্রের নকশা থেকে। George Mealy ১৯৫৫ সালে এমন যন্ত্রের বর্ণনা দেন, যার output নির্ভর করে বর্তমান state আর input দুটির ওপর; Edward Moore ১৯৫৬ সালে আরেকটি রূপ, যেখানে output শুধু state-এর ওপর নির্ভর করে। আজও এ দুটি Mealy machine আর Moore machine নামে পড়ানো হয়। পরে কম্পিউটার বিজ্ঞানে finite automaton ভাষা চেনার মডেল হয়ে ওঠে, আর ডিসক্রিট ম্যাথের পাঠ্যসূচির নিয়মিত অংশ।
Software-এ বড় বদল আসে David Harel-এর statecharts (১৯৮৭) থেকে। সাধারণ state machine বড় system-এ বিশৃঙ্খল হয়ে যায়; Harel nested state, একসাথে চলা অংশ আর history-র ধারণা যোগ করে ছবিকে বড় system-এর উপযোগী করেন। UML-এর state machine diagram মূলত এই statecharts-এর বংশধর।
Test-এর জন্য মডেলটি কাজের, কারণ এটি একটি সসীম প্রশ্নতালিকা দেয়। অসংখ্য সম্ভাব্য event-এর ক্রমকে কয়েকটি state আর ঘরে নামিয়ে আনে: বাজারঘরে ৪২টি ঘর। প্রতিটি ঘর একটি যাচাইযোগ্য দাবি, আর অবৈধ ঘরগুলো এমন প্রশ্ন সামনে আনে যা লিখিত নিয়মে প্রায়ই অনুপস্থিত। মডেলটি দলের যোগাযোগেরও ভাষা: product owner ছবি দেখে বলতে পারেন “না, শিপের পরে বাতিল চলবে না”, কোড না পড়েই।
তবে মডেল নিজেই একটি অনুমান। Mealy আর Moore-এর যন্ত্রে state সসীম আর স্পষ্ট; বাস্তব অর্ডারে লুকানো variable, সময় আর একসাথে আসা event থাকে। তাই মডেলের নির্ভুলতা যাচাই করাও tester-এর কাজ। বাজারঘরের order মডেলে যেমন paid তথ্যটি কোনো বাক্সে নেই, guard-এ লুকানো; মডেল আঁকার পর requirement-এর সাথে বাক্য ধরে মিলিয়ে দেখলে এমন লুকানো তথ্য চোখে পড়ে।
মূল উপলব্ধি: state machine অসীম সম্ভাবনাকে সসীম, গোনা যায় এমন প্রশ্নে রূপ দেয়; এর মূল্য যতটা test বানানোয়, ততটাই requirement-এর ফাঁক খোঁজায়।
প্র ০২Therac-25-এর দুর্ঘটনাকে প্রায়ই “ক্রম আর অবস্থার” ভুলের উদাহরণ বলা হয়। এমন ভুল কেন সাধারণ test-এ ধরা পড়ে না, আর state transition testing কতটা সাহায্য করত?
Therac-25 ছিল একটি বিকিরণ চিকিৎসার যন্ত্র। ১৯৮৫ থেকে ১৯৮৭ সালের মধ্যে কয়েকজন রোগী মাত্রাতিরিক্ত বিকিরণ পান, যার কয়েকটি প্রাণঘাতী। Nancy Leveson আর Clark Turner-এর ১৯৯৩ সালের বিশদ তদন্ত-প্রবন্ধ (IEEE Computer) দেখায়, সমস্যাগুলোর একটি ছিল দ্রুত সম্পাদনার একটি নির্দিষ্ট ক্রম: অপারেটর তথ্য দেওয়ার পর খুব অল্প সময়ের মধ্যে সংশোধন করলে, যন্ত্রের ভেতরের কিছু অংশ সেই সংশোধন দেখতে পেত না। ফলে পর্দায় এক অবস্থা, যন্ত্রের ভেতরে আরেক অবস্থা। একই প্রবন্ধে আরও কয়েকটি কারণ আছে: আগের মডেলের hardware নিরাপত্তা-তালা সরিয়ে software-এর ওপর ভরসা, একটি counter-এর overflow, আর দুর্বল error বার্তা।
এমন ভুল সাধারণ test-এ ধরা পড়ে না, কারণ test সাধারণত “সঠিক input, স্বাভাবিক গতি” ধরে চলে। সমস্যাটি কোনো একক input-এ নেই; আছে input-এর ক্রম আর সময়ে। অভিজ্ঞ অপারেটর দ্রুত হাত চালিয়েছেন, যা test-এর সময় কেউ ভাবেননি।
State transition testing এখানে আংশিক সাহায্য করত। মডেলে “তথ্য দেওয়া”, “সম্পাদনা চলছে”, “যন্ত্র প্রস্তুত হচ্ছে” আলাদা state হিসেবে আঁকলে state table প্রশ্ন তুলত: প্রস্তুত হওয়ার মাঝে সম্পাদনা event এলে কী হবে? সেই ঘরের test হয়তো সমস্যা দেখাত। কিন্তু race condition-এর পুরো সমাধান শুধু মডেল-ভিত্তিক test দিয়ে হয় না: সময়ের সূক্ষ্ম পার্থক্য, একাধিক task-এর একসাথে চলা, আর hardware-এর আচরণ মডেলের বাইরে থাকতে পারে। এ জন্য safety-critical ক্ষেত্রে নকশায় নিরাপত্তা, স্বাধীন hardware তালা আর formal পদ্ধতি একসাথে লাগে।
সাধারণ অনলাইন দোকানেও একই শিক্ষা খাটে: দুবার দ্রুত “টাকা দিন” চাপা, বা বাতিল আর শিপ একসাথে আসা ক্রমের সমস্যা।
মূল উপলব্ধি: অনেক মারাত্মক defect কোনো একক input-এ নয়, ঘটনার ক্রমে থাকে; state মডেল সেই ক্রম নিয়ে প্রশ্ন তোলার কাঠামো দেয়, তবে সময় আর concurrency-র জন্য আরও হাতিয়ার লাগে।
প্র ০৩1-switch-এর পরে 2-switch, 3-switch … কোথায় থামবেন? গভীর coverage-এর খরচ আর লাভ কীভাবে বিচার করবেন?
N-switch coverage-এ N বাড়ালে item-এর সংখ্যা দ্রুত বাড়ে। প্রতিটি state-এ গড়ে k-টি বের হওয়া তীর থাকলে, মোটামুটি প্রতিটি নতুন ধাপে জোড়ার সংখ্যা k গুণ হয়। চক্রওয়ালা মডেলে (যেমন রিচার্জের fail → retry → fail) N-এর কোনো সীমা নেই; লম্বা থেকে লম্বা ক্রম সবই বৈধ। তাই “সব ক্রম test করা” পর্ব ০৩-এর নীতির মতোই অসম্ভব।
গবেষণার দিক থেকে T. S. Chow-এর ১৯৭৮ সালের কাজ দেখায়, যদি ধরে নেওয়া যায় implementation-এ state-এর সংখ্যা মডেলের চেয়ে খুব বেশি নয়, তবে একটি সসীম আর নিয়মমাফিকভাবে তৈরি test সেট নির্দিষ্ট ধরনের সব ভুল (ভুল transition, ভুল output, বাড়তি state) ধরতে পারে। মানে, গভীরতার প্রয়োজন নির্ভর করে আপনি কোড সম্পর্কে কী অনুমান করতে রাজি তার ওপর।
বাস্তবে সিদ্ধান্ত হয় ঝুঁকি দেখে (পর্ব ৭৩)। প্রশ্নগুলো এমন: আগের ধাপের তথ্য কি পরের আচরণে প্রভাব ফেলে? বাজারঘরে paid তথ্য T1 থেকে T8 পর্যন্ত বহন হয়, তাই T7→T8-এর মতো জোড়া ঝুঁকিপূর্ণ; 1-switch সেখানে defect ধরল। কোন পথে টাকা বা নিরাপত্তা জড়িত? সেখানে গভীরে যান। কোন অংশ বারবার বদলায় বা আগে defect দিয়েছে (পর্ব ০৩-এর clustering)? সেখানেও।
আরেকটি কৌশল: N বাড়ানোর বদলে নির্দিষ্ট ক্রম বেছে নেওয়া। যেমন “বাতিল → refund → আবার refund” বা “pay → দ্রুত pay”, যা অভিজ্ঞতা থেকে জানা ঝুঁকি (পর্ব ১৪-এর error guessing). আর এলোমেলো লম্বা ক্রমের জন্য stateful property-based testing (পর্ব ৫৮) যন্ত্রকে দিয়ে হাজারো ক্রম চালায়, invariant (যেমন “একটি অর্ডারে মোট refund কখনো মোট পরিশোধের বেশি নয়”) যাচাই করে।
মূল উপলব্ধি: 0-switch সাধারণ ভিত্তি, অবৈধ ঘর বাধ্যতামূলক, আর তার চেয়ে গভীরে যাওয়া একটি ঝুঁকিভিত্তিক সিদ্ধান্ত, নিয়ম নয়।
প্র ০৪অবৈধ transition-এর “প্রত্যাশিত ফল” কে ঠিক করেন? “কিছুই হবে না” কি যথেষ্ট ভালো উত্তর?
State table-এর ৩৪টি ✗ ঘরের প্রতিটিতে একটি test আছে, কিন্তু প্রত্যাশিত ফল কে বলবেন? প্রায়ই requirement শুধু বৈধ পথ লেখে: “Shipped-এর আগে বাতিল করা যায়।” শিপের পরে বাতিল চাপলে কী হবে, লেখা নেই। এখানে tester-এর কাজ প্রত্যাশিত ফল বানিয়ে নেওয়া নয়, প্রশ্ন করা। এটাই test oracle-এর সমস্যা (পর্ব ০২): উত্তর ঠিক কি না জানতে একটি উৎস লাগে।
“কিছুই হবে না” আংশিক উত্তর। অন্তত চারটি স্তরে প্রত্যাশা লাগে। এক, state: অপরিবর্তিত। দুই, side effect: টাকা কাটা বা ফেরত, SMS, স্টক বদল কিছুই নয়। তিন, ব্যবহারকারীর অভিজ্ঞতা: বোতাম কি লুকানো, নিষ্ক্রিয়, নাকি চাপলে একটি ব্যাখ্যা (“অর্ডারটি কুরিয়ারে চলে গেছে; পৌঁছানোর পর ফেরতের অনুরোধ করতে পারেন”)? চার, API: কোন status code আর error বার্তা; কোনো ক্রমে কি অবৈধ অনুরোধ log করা দরকার, যেমন সন্দেহজনক দ্বিতীয় refund?
কিছু “অবৈধ” ঘর আসলে ব্যবসার সুযোগ। Delivered-এ cancel অবৈধ, কিন্তু সেখান থেকেই “return” নামে নতুন event-এর প্রশ্ন ওঠে। আবার কিছু ঘরে “চুপচাপ উপেক্ষা” ইচ্ছাকৃত: payment gateway একই সফল বার্তা দুবার পাঠালে দ্বিতীয়টি নিঃশব্দে উপেক্ষা করা (idempotency, পর্ব ৭০) error দেখানোর চেয়ে ভালো। ফলে একই ✗ চিহ্নের পেছনে ভিন্ন ভিন্ন প্রত্যাশা থাকতে পারে, আর সেটি ঠিক করেন product owner আর দল একসাথে, tester প্রশ্ন সামনে আনেন।
এই আলোচনা যত আগে হয়, তত ভালো: requirement review-তে state table নিয়ে বসলে (পর্ব ০৬) কোড লেখার আগেই এসব সিদ্ধান্ত হয়, আর পর্ব ১৫-এর acceptance criteria-তে লেখা হয়।
মূল উপলব্ধি: অবৈধ ঘরের প্রত্যাশিত ফল state, side effect, ব্যবহারকারীর বার্তা আর API আচরণ মিলিয়ে লিখতে হয়, আর তা ঠিক করার দায় দলের, অনুমানের নয়।
প্র ০৫Order status যখন একটি নয়, কয়েকটি service-এ ছড়ানো (দোকান, payment, গুদাম, কুরিয়ার), তখন state transition testing কীভাবে বদলায়?
এই পর্বের কোডে state একটি object-এর একটি variable. বড় দোকানে তা নয়: অর্ডারের state থাকে order service-এর database-এ, টাকার তথ্য payment service-এ, প্যাকের তথ্য গুদামের system-এ, আর কুরিয়ারের অবস্থা বাইরের একটি system-এ। Event আসে বার্তা হিসেবে, network দিয়ে, কখনো দেরিতে, কখনো দুবার, কখনো উল্টো ক্রমে।
এতে তিনটি নতুন প্রশ্ন জন্মায়। প্রথম, ক্রম: “পৌঁছেছে” বার্তা যদি “শিপ হয়েছে” বার্তার আগে আসে? মডেলে Packed + deliver ✗, কিন্তু বাস্তবে ঘটনাটি সত্যিই ঘটেছে; system-কে বার্তাটি অপেক্ষায় রাখতে বা ক্রম ঠিক করতে হয়। দ্বিতীয়, পুনরাবৃত্তি: একই “টাকা পাওয়া গেছে” বার্তা দুবার এলে দ্বিতীয়টি Paid + pay, অর্থাৎ অবৈধ ঘর; এখানে প্রত্যাশিত ফল error নয়, নিঃশব্দ উপেক্ষা, যাতে ক্রেতাকে দুবার চার্জ না হয়। তৃতীয়, অস্থায়ী অমিল: কয়েক মুহূর্ত দোকান দেখায় Paid, গুদাম এখনো জানে না; এই eventual consistency-র মধ্যে কোন আচরণ গ্রহণযোগ্য, তা নিয়মে লিখতে হয়।
Testing-এর পদ্ধতিও বদলায়। মডেল-ভিত্তিক unit test এখনো ভিত্তি, কারণ প্রতিটি service-এর নিজস্ব state machine থাকে। তার ওপর লাগে service-এর মাঝের চুক্তির test (contract testing, পর্ব ৩২), বার্তা দুবার বা উল্টো ক্রমে পাঠিয়ে test (পর্ব ৭০), আর production-এ পর্যবেক্ষণ: কোনো অর্ডার কি অস্বাভাবিকভাবে দীর্ঘ সময় এক state-এ আটকে আছে? এমন সতর্কবার্তা আসলে state machine-এর invariant-এর live পাহারা।
এখানে state table-এর একটি নতুন ব্যবহারও আসে: অবৈধ ঘরগুলোর জন্য “বাস্তবে কি এটা ঘটতে পারে?” প্রশ্ন। একক object-এ Shipped + pay হয়তো কখনো ঘটে না; বিতরণকৃত system-এ দেরিতে আসা বার্তায় ঘটতেই পারে।
মূল উপলব্ধি: বিতরণকৃত system-এ অবৈধ ঘর আর তত্ত্বের প্রশ্ন থাকে না, নিয়মিত ঘটনা হয়ে যায়; তাই সেখানে অবৈধ transition-এর আচরণ নকশা আর test দুটোরই কেন্দ্রে।
অনুশীলন
খাতা-কলমে করুন; উত্তর খোলার আগে নিজের উত্তর লিখে রাখুন।
-
Test design, OTP login থেকে: বাজারঘরের (কাল্পনিক) login নিয়ম: LoggedOut অবস্থায় OTP চাইলে (
request) state OtpSent. OtpSent-এ সঠিক OTP দিলে (correct) LoggedIn; ভুল দিলে (wrong) OtpSent-এ থাকে, কিন্তু পরপর তৃতীয় ভুলে Locked. OtpSent-এ আবার OTP চাওয়া যায় (ভুলের গণনা শূন্য হয় না)। LoggedIn থেকেlogoutকরলে LoggedOut. Locked শেষ অবস্থা। (ক) State table-এ কয়টি ঘর, কয়টি ঘরে বৈধ পথ, কয়টি অবৈধ? (খ) সব বৈধ transition (0-switch) ঢাকতে সবচেয়ে কম কয়টি test, কী কী?(ক) ৪টি state × ৪টি event = ১৬টি ঘর। বৈধ transition ৬টি: LoggedOut–request, OtpSent–correct, OtpSent–wrong [গণনা < ৩] (থাকে), OtpSent–wrong [তৃতীয় ভুল] (Locked), OtpSent–request (আবার পাঠানো), LoggedIn–logout. কিন্তু দুটি wrong-transition একই ঘরে, guard দিয়ে আলাদা; তাই বৈধ পথওয়ালা ঘর ৫টি, অবৈধ ঘর ১৬ − ৫ = ১১টি (scratch script-এ গোনা)। Guard-ওয়ালা ঘরটিতে দুটি test লাগবে, ঠিক Cancelled–refund-এর মতো।
(খ) দুটি test যথেষ্ট, কারণ Locked শেষ অবস্থা, আর সেখানে পৌঁছানো test-এর পরে আর কিছু চলে না:
- A: request, wrong, request, correct, logout — পাঁচটি transition: request, wrong (প্রথম ভুল, থাকে), আবার request, correct, logout.
- B: request, wrong, wrong, wrong — তৃতীয় ভুলে Locked.
মোট ৯টি event-এ ৬টি বৈধ transition. সাথে প্রত্যাশিত ফল লিখুন: A-র শেষে LoggedOut; B-র শেষে Locked, আর তারপর
correctদিলেও login হয় না (একটি অবৈধ ঘর)। একটি প্রশ্নও তুলুন: Locked কতক্ষণ? চিরস্থায়ী, নাকি নির্দিষ্ট সময় পরে খোলে? নিয়মে নেই। -
আউটপুট অনুমান করুন: এক developer-এর table-এ বাড়তি একটি সারি আছে:
("Packed", "deliver"): "Delivered"(শিপ ছাড়াই ডেলিভারি)। দুটি test:test_journeyচালায় pay, pack, ship, deliver আর আশা করে Delivered;test_deliver_before_shipচালায় pay, pack, তারপরwith self.assertRaises(ValueError): o.handle("deliver"), তারপরassertEqual(o.state, "Packed").TextTestRunner(verbosity=1)কী ছাপবে, প্রথম লাইনে কোন চিহ্ন কোন ক্রমে?আসল ফল (scratch-এ চালানো, traceback ছাঁটা):
F. FAIL: test_deliver_before_ship (__main__.OrderTests.test_deliver_before_ship) … AssertionError: ValueError not raised Ran 2 tests in 0.001s FAILED (failures=1)unittest test method-গুলো নামের বর্ণানুক্রমে চালায়:
test_deliver_before_ship(d) আগে,test_journey(j) পরে। তাই প্রথম লাইনেF.: আগে fail, পরে পাস। অবৈধ ঘর (Packed, deliver) কোডে খোলা, তাইValueErrorওঠেনি;assertRaisescontext manager বার্তা দেয় “ValueError not raised”. দ্বিতীয় assertion (state Packed) আর চলেইনি, কারণ প্রথম assertion fail করলে test সেখানেই থামে। Happy path-এর test পাস করেছে: খোলা অবৈধ পথ বৈধ পথের test-এ ধরা পড়ে না। -
Test-এর ভুল খুঁজুন: এক সহকর্মী “শিপের পরে বাতিল অবৈধ” যাচাইয়ের জন্য এই test লিখেছেন, আর বলছেন এটি সবসময় পাস করে, তাই কোড ঠিক আছে:
Test-টিতে কী সমস্যা, আর কীভাবে ঠিক করবেন?def test_cancel_after_shipped(self): o = Order() o.handle("pay"); o.handle("pack"); o.handle("ship") try: o.handle("cancel") except ValueError: passTest-এ কোনো assertion নেই। কোড
ValueErrorতুললেexceptসেটি গিলে ফেলে, test পাস। কোড ভুলভাবে বাতিল মেনে নিলে কোনো exception ওঠে না, test-ও পাস। দুই ক্ষেত্রেই সবুজ, অর্থাৎ এই test কখনো fail করতে পারে না; এটি কিছুই যাচাই করে না। §৬-এর seeded defect-ওয়ালা কোডেও এটি পাস করত। দ্বিতীয় অভাব: state অপরিবর্তিত কি না দেখা হয়নি।ঠিক করা রূপ:
def test_cancel_after_shipped(self): o = Order() o.handle("pay"); o.handle("pack"); o.handle("ship") with self.assertRaises(ValueError): o.handle("cancel") self.assertEqual(o.state, "Shipped")যাচাই করুন: কোডে ইচ্ছা করে Shipped-এ cancel খুলে দিন; নতুন test লাল হওয়া উচিত। যে test কখনো লাল হতে পারে না, সেটি test নয়।
-
গণনা, পরীক্ষার ধাঁচে: মোবাইল রিচার্জের অনুরোধ (কাল্পনিক): Draft থেকে
submitকরলে Pending; Pending থেকেokহলে Success,failহলে Failed; Failed থেকেretryকরলে আবার Pending. Success শেষ অবস্থা। (ক) State table-এ মোট ঘর আর অবৈধ ঘর কয়টি? (খ) 1-switch জোড়া কয়টি, কোনগুলো? (গ) সবচেয়ে কম কয়টি test-এ সব বৈধ transition ঢাকা যায়? আর সব 1-switch জোড়া?(ক) ৪ state × ৪ event = ১৬ ঘর; বৈধ ৪টি, অবৈধ ১২টি।
(খ) সূত্র: Pending-এ ঢোকে ২টি (submit, retry), বের হয় ২টি (ok, fail): ২ × ২ = ৪। Failed-এ ঢোকে ১টি (fail), বের হয় ১টি (retry): ১। Draft-এ কিছু ঢোকে না, Success থেকে কিছু বের হয় না। মোট ৫টি: submit→ok, submit→fail, retry→ok, retry→fail, fail→retry.
(গ) একটি test-এই চারটি বৈধ transition: submit, fail, retry, ok. এটি তিনটি জোড়াও ঢাকে (submit→fail, fail→retry, retry→ok). বাকি দুটি জোড়ার জন্য: submit, fail, retry, fail, retry, ok (retry→fail যোগ হলো) আর submit, ok. অর্থাৎ ২টি test-এ সব ৫টি জোড়া (script-এ যাচাই করা)। লক্ষ করুন, এখানে চক্র আছে (fail → retry → fail …), তাই 2-switch বা তার বেশিতে গেলে ক্রমের দৈর্ঘ্যের কোনো সীমা নেই; বাস্তবে retry-এর সর্বোচ্চ সংখ্যা একটি guard দিয়ে নিয়মে লেখা উচিত।
নিজেকে যাচাই করুন
উত্তর বাছুন; সাথে সাথে ব্যাখ্যা দেখাবে।
ক্রমState transition testing-এ test নকশার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Requirement থেকে state, event, guard আর action চিহ্নিত করা
- State diagram এঁকে প্রতিটি transition-এর নাম দেওয়া
- State table বানিয়ে বৈধ আর অবৈধ ঘর চিহ্নিত করা, অস্পষ্ট ঘর নিয়ে প্রশ্ন তোলা
- ঝুঁকি দেখে coverage লক্ষ্য বাছাই করা (0-switch, 1-switch, অবৈধ ঘর)
- Test sequence আর প্রতিটি ধাপের প্রত্যাশিত ফল লেখা
- Test চালিয়ে coverage মাপা আর ফাঁক থাকলে নতুন sequence যোগ করা
একটি state machine-এ ৫টি state আর ৪টি event আছে, আর বৈধ transition ৭টি (প্রতিটি আলাদা ঘরে, কোনো guard নেই)। State table-এ অবৈধ ঘর কয়টি?
- ৯টি
- ২০টি
- ১৩টি
- ৭টি
একটি অনলাইন দোকানের অর্ডারের test suite-এ প্রতিটি বৈধ transition অন্তত একবার চলেছে, কিন্তু কোনো অবৈধ event পাঠানো হয়নি। কোডে ভুল করে “শিপ হওয়ার পরেও বাতিল” খোলা আছে। কোন বক্তব্যটি সঠিক?
- 0-switch ১০০% হওয়ায় defect-টি নিশ্চিতভাবে ধরা পড়েছে
- Defect-টি ধরা পড়েনি; all transitions (অবৈধ ঘরসহ) coverage লাগবে
- All states coverage যোগ করলে defect-টি ধরা পড়বে
- এমন defect state transition testing দিয়ে ধরা অসম্ভব
একটি মডেলে transition: t1 (A থেকে B), t2 (B থেকে C), t3 (B থেকে D), t4 (C থেকে B). কোনো guard নেই। 1-switch coverage-এর জন্য মোট কয়টি জোড়া?
- ৪টি
- ৩টি
- ৬টি
- ৫টি
State transition testing-এ প্রতিটি test case-এ সাধারণত একটিমাত্র অবৈধ event রাখার পরামর্শ দেওয়া হয়। প্রধান কারণ কী?
- একটি ভুল আরেকটি ভুলকে ঢেকে দিতে পারে (fault masking)
- Test framework একটির বেশি exception ধরতে পারে না
- অবৈধ event কম পাঠালে test কম লাগে
- অবৈধ event-এর কোনো প্রত্যাশিত ফল থাকে না
একটি অর্ডারের মডেলে transition আছে: Cancelled থেকে refund [paid] দিয়ে Refunded. টাকা না দিয়েই বাতিল করা একটি অর্ডারে refund পাঠানো হলো। প্রত্যাশিত ফল কী?
- State Refunded, কিন্তু টাকা শূন্য
- State আবার Placed
- প্রত্যাখ্যান; state Cancelled থাকে, কোনো action নয়
- System crash করা উচিত
একটি test suite একটি অর্ডারের মডেলের ৮টি বৈধ transition-ই চালায়, কিন্তু 1-switch-এর ৭টি জোড়ার ৬টি ঢাকে। কোনো defect কেবল একটি নির্দিষ্ট জোড়ায় (প্যাকের পরে বাতিল, তারপর refund) দেখা দেয়। কোন বক্তব্য সঠিক?
- সব transition চলেছে, তাই defect অবশ্যই ধরা পড়েছে
- Defect ধরা না-ও পড়তে পারে; 1-switch coverage ৮৫.৭%, বাদ পড়া জোড়াটি যোগ করতে হবে
- 0-switch ১০০% মানে 1-switch-ও ১০০%
- All states coverage যোগ করলেই যথেষ্ট
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- ফল যখন আগে কী ঘটেছে তার ওপর নির্ভর করে, তখন system-কে state, event, guard আর action-এর যন্ত্র হিসেবে আঁকুন।
- State table = state × event ঘর; বাজারঘরে ৪২টি, ৮টি বৈধ, ৩৪টি অবৈধ। প্রতিটি ঘর একটি প্রশ্ন, আর অস্পষ্ট ঘর requirement-এর ফাঁক।
- চারটি মাপ: all states < 0-switch (সব বৈধ transition) < 1-switch (সব সম্ভব জোড়া; কোনো জোড়ায় নেই এমন transition, যেমন T5, আলাদা test-এ রাখুন); আর all transitions অবৈধ ঘরসহ। জোড়া গুনুন (ঢোকা × বের হওয়া), guard-এ অসম্ভবগুলো বাদ দিন।
- অবৈধ event প্রতি test-এ একটি; প্রত্যাশিত ফল: প্রত্যাখ্যান, state অপরিবর্তিত, কোনো action নয়। Guard-এর দুই দিকই test করুন।
- শুধু বৈধ পথের test খোলা অবৈধ পথ ধরে না, আর শুধু একক transition জোড়ার bug ধরে না; রিপোর্টে সবসময় লিখুন কোন মাপের coverage.
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ১১ · Pairwise আর combinatorial testing — কম test-এ বেশি মিশ্রণপরবর্তী পর্বকম test-এ বেশি মিশ্রণ ঢাকার কৌশল।
- সফটওয়্যার টেস্টিং ও QA · কোর্স হোম৮২টি পর্ব১৪টি মডিউলের পুরো রোডম্যাপ।
- সফটওয়্যার ইঞ্জিনিয়ারিং ও Git · পর্ব ৪৭পাশের ট্র্যাকTest design-এর সব কৌশল সংক্ষেপে, বাস-টিকিটের state machine সহ।
- সফটওয়্যার ইঞ্জিনিয়ারিং ও Git · পর্ব ৩০পাশের ট্র্যাকUML state machine diagram আঁকার নিয়ম।
- ডিসক্রিট ম্যাথ · পর্ব ৭৪গভীরে যানFinite automaton: state machine-এর গাণিতিক ভিত্তি।