Automatic Test Case Generation from UML Activity Diagram Using Activity Path

The most important part of the testing attempt is the test case generation. As a modeling language, Unified Modeling Language (UML) is the most generally used to describe design specifications and analysis by both academic and industry. Therefore, UML becomes the sources of Test Case Generation. Test cases are usually generated from the requirement, and UML activity diagram illustrates the sequential control flows of activities what make it possible to generate test cases for activity diagrams. This research proposes an approach to automatically generate test cases directly from UML activity diagram using activity graph. Therefore, this research will create an algorithm and implement it on a prototype using the UML activity diagram as an input to generate the test cases. The result of all these test cases will be compared to the result that has been generated manually to evaluate the usability and reliability of the proposed algorithm

An evaluation on the comprehensibility of UML activity and state chart diagrams with regard to manual test generation

The activity and state chart diagrams are the most frequently used UML diagrams for testing a system based on its specification. One of the key important qualities of the UML diagrams is their comprehensibility. The content analysis of previous studies highlighted the lack of experts’ evaluation of the comprehensibility of activity and state chart diagrams with regard to test case generation. Thus, the main objective of this study is to evaluate the comprehensibility of the UML activity and state chart diagrams for test case generation. First, a content analysis was performed to identify the comprehensibility criteria. The criteria are perceived difficulty and subjective confidence. Next, a set of evaluation questions was designed based on the content analysis. Then, test cases were generated from activity and state chart diagrams manually of an adapted case study. An interview was conducted with five experts to validate the evaluation questions. The experts evaluated the comprehensibility of the activity and state chart diagrams by using the evaluation questions. The result of the study provided specific details of the different characteristics of activity and state chart diagrams. Further, it suggested that the activity diagram is more comprehensible than the state chart diagram in the aspect of test case generation. The finding of this study could assist software testers in choosing the appropriate UML diagrams for software testing

AD2US: An Automated Approach to Generating Usage Scenarios from UML Activity Diagrams

Although attention has been given to the use of UML (Unified Modelling Language) activity diagrams in the generation of scenarios, thin-threads and test-cases, the processes described in the literature rely heavily on manual intervention either in the information extraction process or in the process of transforming them to an alternate structure. This paper introduces an approach that capture, store and output usage scenarios derived automatically from UML activity diagrams

Using Adaptive Agents to Automatically Generate Test Scenarios from the UML Activity Diagrams

Test case generation is one of the most important issues in software testing research and industrial practice. Test scenarios are frequently used to derive test cases for scenario-based software testing. However, the generation of the test scenarios is usually a manual and labor-intensive task. It is desired that test scenarios can be automatically generated. In this paper, we propose an automated approach using adaptive agents to directly generate test scenarios from the UML activity diagrams

Test case generation technique for concurrency in activity diagram

Presently, the application of Model-Based Testing (MBT) using Unified Modelling Language (UML) has attracted the attention of many practitioners to use UML diagrams for generation of test cases. By using this technique, early detection of faults can be achieved at the design phase. However, some UML diagrams have limitations in generating test cases such as the need for a loop combination fragment to describe looping, iteration process and combination fragment with the par operator to interpret concurrency activities. To overcome these issues, a feature analysis was conducted to observe the outcome of test case generation using similar cases but, by using different techniques and UML diagrams. Based on the results, a guideline for selecting UML diagrams in the generation of test cases based on the different features of software system in the cases was developed. However, system design of concurrent software is complex, leading to issues in system testing such as synchronization, non-deterministic, path explosion and deadlock. In this research, an enhancement of the generate-activity-paths algorithm as a test case generation technique was developed to solve the non-deterministic problem of concurrent system. As the test cases are generated in a random order, a prioritization technique using genetic algorithm was applied to find the critical path that must be tested first from the test paths produced. The technique was implemented on the Conference Management System case study and evaluated using cyclomatic complexity, branch coverage, mutation analysis and average percentage of fault detected (APFD) to measure the effectiveness and quality of the test cases in comparison to those using the original technique. Results indicated that the technique achieved 100% basis path and branch coverage criteria similar to the original technique. Moreover, it is also capable of revealing non-deterministic faults by injecting concurrency coverage criteria into the test paths, which was not possible using the original technique. Additionally, prioritization of test paths yielded an APFD value of 43% which is better and higher than the non-prioritized test paths (22%). This result signified that the usage of prioritization technique leads to an improve detection rate of severe faults as compared to applying random order

Automatic generation of test cases from activity diagrams for UML based testing (UBT)

Activity diagrams are one of UML behavioural models suitable for system testing because it has the capacity to effectively describe the behaviours of systems under development. In this paper, a technique is proposed that generates test cases from activity diagrams by constructing an activity flow tree (AFT) which stores all the information extracted from the model file of the diagram through the help of a parser. Then, we applied an algorithm to generate test cases from the constructed tree. Test cases were generated based on the elements of activity diagrams such as activity sequences, associated descriptions and conditions. The proposed technique generated accurate test cases that completely tallied with the modeled requirements in the diagram. We utilized all-paths, basic pair paths, conditions, branches and transition criteria for generating test cases using ATM withdrawal operation software as a case study

Test case generation using UML behavioral & structural models

Quality software can be developed when it is properly tested. Due to increase in the size and complexity of object-oriented software, manual testing has become time, resource and cost consuming. Properly designed test cases discover more errors and bugs present in the software. The test cases can be generated much early in the software development process, during the design phase. The unified modeling language (UML) is the most widely used language to describe the analysis and designs of object-oriented software. Test cases can be derived from UML models more efficiently. In our work, we propose a novel approach for automatic test case generation from the combination of UML class and activity diagrams. In our approach, we first draw the UML class and activity diagrams using IBM Rational Software Architect (RSA). Then, export the XML metadata interchange (XMI) from IBM Rational Software Architect (RSA). The XMI file is processed to extract variables from the class and predicates from activity diagram using Java code. The predicates are then used to generate the test cases. We have not used any intermediate form which makes the automation difficult. Our approach achieves 100% branch coverage and suitable for mutation testing and unit testing. In our next work, we focus on UML composite structure diagram to generate test scenarios for integration testing. In our approach, we first draw the UML composite structure diagram using IBM Rational Software Architect (RSA). Then, export the XML metadata interchange (XMI) representation of composite structure diagram from IBM Rational Software Architect. Then, we parse the XMI code and generate the Component Structure Graph (CSG) automatically. Subsequently, we propose two algorithms to generate test scenarios for Top-Down and Bottom-Up integration approach. The generated test scenarios are sufficient enough to find the component in which probability of bug presence is maximum

A test case generation framework based on UML statechart diagram

Early software fault detection offers more flexibility to correct errors in the early development stages. Unfortunately, existing studies in this domain are not sufficiently comprehensive in describing the major processes of the automated test case generation. Furthermore, the algorithms used for test case generation are not provided or well described. Current studies also hardly address loops and parallel paths issues, and achieved low coverage criteria. Therefore, this study proposes a test case generation framework that generates minimized and prioritized test cases from UML statechart diagram with higher coverage criteria. This study, conducted a review of the previous research to identify the issues and gaps related to test case generation, model-based testing, and coverage criteria. The proposed framework was designed from the gathered information based on the reviews and consists of eight components that represent a comprehensive test case generation processes. They are relation table, relation graph, consistency checking, test path minimization, test path prioritization, path pruning, test path generation, and test case generation. In addition, a prototype to implement the framework was developed. The evaluation of the framework was conducted in three phases: prototyping, comparison with previous studies, and expert review. The results reveal that the most suitable coverage criteria for UML statechart diagram are all-states coverage, all-transitions coverage, alltransition-pairs coverage, and all-loop-free-paths coverage. Furthermore, this study achieves higher coverage criteria in all coverage criteria, except for all-state coverage, when compared with the previous studies. The results of the experts’ review show that the framework is practical, easy to implement due to it is suitability to generate the test cases. The proposed algorithms provide correct results, and the prototype is able to generate test case effectively. Generally, the proposed system is well accepted by experts owing to its usefulness, usability, and accuracy. This study contributes to both theory and practice by providing an early alternative test case generation framework that achieves high coverage and can effectively generate test cases from UML statechart diagrams. This research adds new knowledge to the software testing field, especially for testing processes in the model-based techniques, testing activity, and testing tool support

Test Case Generation using UML Activity Diagram & Composite Structure Diagram

In software development, Quality is an important thing. We get the best quality of software when we test it properly. In present day the size and complexity in object oriented software are increased , Due to this manual testing become very resource consuming and not able to provide proper results. To handle this we need automatic test case generation which helps in finding the errors and bugs. Test cases we generate in design phase only, which is very early in software development process. We use unified modelling language (UML) to visualise the designs and structure of object-oriented software. From UML diagram, we generate efficient test cases which gives proper results during testing. We first focus on the generation of test cases from the Activity diagram. Activity Diagrams are used to describe the behaviour of the models i.e. dynamic aspects of model. In activity diagram we describe the flow of activity from one to another. Every activity represents a different operation. We first use Rational Software Architect (RSA) to develop the Activity Diagram. From here we generate XMI (XML metadata interchange). We generate the intermediate graph by parsing the XMI code automatically. After developing the intermediate graph , by using it, in our proposed algorithm topdown test case generation algorithm we generate test cases. The generated test cases are used in testing to find out the errors, by removing erros we increase the quality of the software. In our next work, we focus on the UML composite structure diagram (CSD). CSD defines the interaction between components because of this we use these generated test scenarios in the integration testing. We first use Rational Software Architect (RSA) to develop the CSD. From here we generate XMI (XML metadata interchange). We generate the intermediate graph by parsing the XMI code automatically. By using intermediate graph, in our algorithm we generate test scenarios. The generated test scenarios are used in integration testing to find out the errors