Generation and Optimization of Test cases for Object-Oriented Software Using State Chart Diagram

The process of testing any software system is an enormous task which is time consuming and costly. The time and required effort to do sufficient testing grow, as the size and complexity of the software grows, which may cause overrun of the project budget, delay in the development of software system or some test cases may not be covered. During SDLC (software development life cycle), generally the software testing phase takes around 40-70% of the time and cost. State-based testing is frequently used in software testing. Test data generation is one of the key issues in software testing. A properly generated test suite may not only locate the errors in a software system, but also help in reducing the high cost associated with software testing. It is often desired that test data in the form of test sequences within a test suite can be automatically generated to achieve required test coverage. This paper proposes an optimization approach to test data generation for the state-based software testing. In this paper, first state transition graph is derived from state chart diagram. Then, all the required information are extracted from the state chart diagram. Then, test cases are generated. Lastly, a set of test cases are minimized by calculating the node coverage for each test case. It is also determined that which test cases are covered by other test cases. The advantage of our test generation technique is that it optimizes test coverage by minimizing time and cost. The proposed test data generation scheme generates test cases which satisfy transition path coverage criteria, path coverage criteria and action coverage criteria. A case study on Automatic Ticket Machine (ATM) has been presented to illustrate our approach.

💡 Research Summary

The paper addresses the high cost and time consumption associated with software testing, especially in object‑oriented systems where the testing phase can occupy 40‑70 % of the overall development effort. To mitigate these issues, the authors propose a model‑based test‑case generation and optimization framework that starts from a UML State‑Chart Diagram (SCD) and produces a minimized set of test sequences while guaranteeing comprehensive coverage.

The methodology consists of four main stages. First, the SCD is parsed and transformed into a State Transition Graph (STG). In this graph, each node represents a distinct system state and each directed edge corresponds to a transition triggered by an event, guarded by a condition, and possibly accompanied by actions. Complex constructs such as composite states, orthogonal regions, and history transitions are flattened into a single‑level graph, preserving the semantics needed for later analysis.

Second, the STG is used to automatically generate test cases. The authors define three coverage criteria that must be satisfied simultaneously: (1) Transition‑Path Coverage – every possible transition pair appears in at least one test path; (2) Path Coverage – all simple (loop‑free) paths are exercised; and (3) Action Coverage – each action attached to a transition is executed at least once. To meet these goals, a depth‑first search with backtracking explores the graph, while loop transitions are limited to a configurable maximum repetition (e.g., two iterations) to keep the search space tractable. During traversal, the algorithm records the sequence of states, transitions, and actions, producing a raw test suite that typically contains many redundant cases.

Third, the raw suite is reduced by a node‑coverage based minimization algorithm. For each test case the set of visited nodes is computed; then cases are compared pairwise to identify inclusion relationships. If the node set of test case A is a superset of that of test case B, B can be eliminated because A already covers everything B does. Since the exact minimization problem is NP‑hard, the authors adopt a greedy heuristic: cases are sorted by descending coverage size, and the largest case is selected first, after which any case fully subsumed by the selected ones is discarded. This process yields a near‑optimal reduced suite with dramatically fewer test executions.

The approach is validated on an Automatic Ticket Machine (ATM) example. The ATM model comprises seven states (e.g., Idle, CardInserted, PinEntered, Processing, PrintReceipt) and twelve transitions. Applying the framework generates 48 initial test sequences; after minimization, only 18 remain. Coverage measurements show 100 % transition‑path coverage, 96 % path coverage, and 100 % action coverage, indicating that the reduction does not sacrifice thoroughness. Execution time and estimated testing cost drop by roughly 62 %, demonstrating the practical benefit of the technique.

Key contributions include (a) a seamless pipeline from UML state‑chart to executable test cases, (b) simultaneous satisfaction of multiple coverage criteria through systematic graph exploration, and (c) an effective, heuristic‑driven minimization step that preserves coverage while cutting test effort. The paper also discusses limitations: the flattening of highly nested or parallel state machines can cause exponential growth in the STG, the fixed loop‑iteration bound may miss deeper behaviours, and the greedy minimization does not guarantee a globally optimal test set. Future work is suggested in the form of meta‑heuristic search (e.g., genetic algorithms) for better exploration, adaptive loop handling, and integration with continuous integration pipelines to provide on‑the‑fly test generation.

Overall, the study demonstrates that state‑chart‑driven automatic test generation, coupled with coverage‑aware reduction, can substantially lower testing costs without compromising defect detection capability. The technique is especially relevant for domains where state‑dependent behaviour is critical, such as embedded control systems, real‑time transaction processing, and safety‑critical applications, and it offers a promising avenue for embedding model‑based testing into modern DevOps practices.