Model-based Test Case Generation Research Articles

The optimization path of core literacy of innovative talents in universities based on the improved Markov model

Abstract As we enter the information technology era of the 21st century, universities are the main place for talent cultivation, but as an important part of higher Education, they are not sufficiently aware of innovative talent cultivation, and their own development is immature, which leads to the unsound innovative talent cultivation model. Therefore, in this paper, we use the Markov model-based test case generation technique to explore in depth the techniques of transfer probability acquisition, random selection, and adequacy determination and improve the Markov model with linear regression to further strengthen the robustness of the prediction algorithm, reduce the error of prediction and improve the accuracy of prediction. Through the processing of student data, the results show that the standard deviation of the improved Markov model is 0.06903 and the processing time is 87 seconds, the standard deviation of the original model is 0.07255 and the processing time is 133 seconds, and the larger the standard deviation of the experimental sample the less accurate the experiment is. The improved Markov model has a good experimental effect with little error, which can effectively optimize the training mode of innovative talents in universities.

A Systematic Mapping Study on UML Model based Test Case Generation and Optimization Techniques

A Systematic Mapping Study on UML Model based Test Case Generation and Optimization Techniques

Automatic Generation and Optimization of Combinatorial Test Cases from UML Activity Diagram Using Particle Swarm Optimization

Generation of test cases is one of the essential activities of the software testing process. The process of executing a programme to identify defects to improve the system's quality is known as software testing. Manually writing test cases takes time, effort, and money. On the other hand, generating test cases automatically is the solution to this problem. For this automation process, a model-based test case generation technique would be acceptable. A model is usually required to generate test cases in the model-based testing technique. Nowadays, researchers have relied on the activity diagram to generate test cases. Test cases for combinatorial logic systems are required. Combinatorial testing is essential for producing a small number of test cases and identifying errors occurred by interactions between system input parameters. Information about constraints, parameters and its values are required for generation of test cases. It is difficult to extract information regarding constraints, parameters, its values, and interactions between parameters from an Activity Diagram. A novel approach is proposed to extract this information from an Activity Diagram. The authors created a tool that automatically generates combinatorial test cases using UML Activity Diagrams. The proposed tool has two main parts. First, the combinatorial test design model is developed for extraction of input parameters. Second part is generation of optimized number of combinatorial test cases using Particle Swarm Optimization algorithm. Finally, the authors experimented on a real-world case study namely viz. Railway Reservation using the proposed tool, and it is shown that the proposed tool generated optimum number of combinatorial test cases.

An EFSM-Based Test Data Generation Approach in Model-Based Testing

Testing is an integral part of software development. Current fast-paced system developments have rendered traditional testing techniques obsolete. Therefore, automated testing techniques are needed to adapt to such system developments speed. Model-based testing (MBT) is a technique that uses system models to generate and execute test cases automatically. It was identified that the test data generation (TDG) in many existing model-based test case generation (MB-TCG) approaches were still manual. An automatic and effective TDG can further reduce testing cost while detecting more faults. This study proposes an automated TDG approach in MB-TCG using the extended finite state machine model (EFSM). The proposed approach integrates MBT with combinatorial testing. The information available in an EFSM model and the boundary value analysis strategy are used to automate the domain input classifications which were done manually by the existing approach. The results showed that the proposed approach was able to detect 6.62 percent more faults than the conventional MB-TCG but at the same time generated 43 more tests. The proposed approach effectively detects faults, but a further treatment to the generated tests such as test case prioritization should be done to increase the effectiveness and efficiency of testing.

Model-based test case generation and prioritization: a systematic literature review

Model-based test case generation and prioritization: a systematic literature review

Model-based test case generation from UML sequence diagrams using extended finite state machines

The effectiveness of model-based testing (MBT) is mainly due to its potential for automation. If the model is formal and machine-readable, test cases can be derived automatically. One of the most used formal modeling techniques is the interpretation of a system as an extended finite state machine (EFSM). However, formal models are not a common practice in the industry. The Unified Modeling Language (UML) has become the de facto standard for software modeling. Nevertheless, due to the lack of formal semantics, its diagrams can be given ambiguous interpretations and are not suitable for testing automation. This article introduces a systematic procedure for the generation of tests from UML models that uses concepts of model-driven engineering (MDE) for formalizing UML sequence diagrams into extended finite state machines and providing a precise semantics for them. It also applies ModelJUnit and JUnit libraries for an automatic generation of test cases. A case study was conducted in a real software towards the evaluation of its applicability.

An Enhanced Multiview Test Case Generation Technique for Object-oriented Software using Class and Activity Diagrams

Software testing is one of the vital steps in software development life cycle. Test case generation is the first process in software testing which takes a lot of time, cost and effort to build an effective product from the start. Automatic test case generation is the best way to address this issue and model-based test case generation approach would be suitable for this automation process. One way to generate test cases automatically is by generating test cases from Unified Modeling Language (UML) models. The challenge with the existing test case generation techniques using UML models is that they provide a single view, meaning that the techniques capture a single aspect of the system, such as structural or behavioral but not both. In this paper, we have successfully developed a technique that automatically generates test cases which capture both structural and behavioral views of the system. These test cases can help to discover software faults early in the software development cycle. Finally, we conducted an experiment by comparing our technique with a manual process. The results show that the proposed technique can produce same test cases as manually writing test cases of the same system model but this technique saves a lot of time, effort and cost as well.

Mixed-semantics composition of statecharts for the component-based design of reactive systems

The increasing complexity of reactive systems can be mitigated with the use of components and composition languages in model-driven engineering. Designing composition languages is a challenge itself as both practical applicability (support for different composition approaches in various application domains), and precise formal semantics (support for verification and code generation) have to be taken into account. In our Gamma Statechart Composition Framework, we designed and implemented a composition language for the synchronous, cascade synchronous and asynchronous composition of statechart-based reactive components. We formalized the semantics of this composition language that provides the basis for generating composition-related Java source code as well as mapping the composite system to a back-end model checker for formal verification and model-based test case generation. In this paper, we present the composition language with its formal semantics, putting special emphasis on design decisions related to the language and their effects on verifiability and applicability. Furthermore, we demonstrate the design and verification functionality of the composition framework by presenting case studies from the cyber-physical system domain.

Extreme modelling in practice

Formal modelling is a powerful tool for developing complex systems. At MongoDB, we use TLA + to model and verify multiple aspects of several systems. Ensuring conformance between a specification and its implementation can add value to any specification; it can avoid transcription errors, prevent bugs as a large organization rapidly develops the specified code, and even keep multiple implementations of the same specification in sync. In this paper, we explore model-based testing as a tool for ensuring specification-implementation conformance. We attempted two case studies: model-based trace-checking (MBTC) in the MongoDB Server's replication protocol and model-based test-case generation (MBTCG) in MongoDB Realm Sync's operational transformation algorithm. We found MBTC to be impractical for testing that the Server conformed to a highly abstract specification. MBTCG was highly successful for Realm Sync, however. We analyze why one technique succeeded and the other failed, and advise future implementers making similar attempts at model-based testing.

Prioritized Process Test: An Alternative to Current Process Testing Strategies

Testing processes and workflows in information and Internet of Things systems is a major part of the typical software testing effort. Consistent and efficient path-based test cases are desired to support these tests. Because certain parts of software system workflows have a higher business priority than others, this fact has to be involved in the generation of test cases. In this paper, we propose a Prioritized Process Test (PPT), which is a model-based test case generation algorithm that represents an alternative to currently established algorithms that use directed graphs and test requirements to model the system under test. The PPT accepts a directed multigraph as a model to express priorities, and edge weights are used instead of test requirements. To determine the test-coverage level of test cases, a test-depth-level concept is used. We compared the presented PPT with five alternatives (i.e. the Process Cycle Test (PCT), a naive reduction of test set created by the PCT, Brute Force algorithm, Set-covering-Based Solution and Matching-based Prefix Graph Solution) for edge coverage and edge-pair coverage. To assess the optimality of the path-based test cases produced by these strategies, we used 14 metrics based on the properties of these test cases and 59 models that were created for three real-world systems. For all edge coverage, the PPT produced more optimal test cases than the alternatives in terms of the majority of the metrics. For edge-pair coverage, the PPT strategy yielded similar results to those of the alternatives. Thus, the PPT strategy is an applicable alternative as it reflects both the required test coverage level and the business priority in parallel.

A novel approach for automatic model-based test case generation

This paper proposes a new method for automatic generation of test cases using model based testing. As test model, class and state diagrams are used, and constraints are expressed using OCL. First, the state machineis converted into a mathematical representation in AMPL. Then, using a search algorithm and based upon coverage criteria, the abstract paths are selected from state machine. Second, using symbolic execution,the generated abstract path along with the constraints on this path is converted into the data of generated mathematical model. Third, the generated mathematical problem is solved with solvers that have interfacewith AMPL, and the test data is produced for each abstract test case. Finally, the generated test data and abstract paths are transformed into executable test cases. All-Transitions and All-States coverage criteria areused for conduct search algorithm, as well as the criteria for evaluate the quality of generated test cases. To validate the work, by utilizing various solvers, the test cases are generated for various problems.The proposed technique is implemented as a tool, named MoBaTeG. The tool shows good result in terms of test case generation execution time, test goals satisfaction rate, source code instructions coverage, andalso boundary values generation.

Goal-based testing of semantic web services

Context: Recent years have witnessed growing interests in semantic web and its related technologies. While various frameworks have been proposed for designing semantic web services (SWS), few of them aim at testing.Objective: This paper investigates into the technologies for automatically deriving test cases from semantic web service descriptions based on the Web Service Modeling Ontology (WSMO) framework.Method: WSMO goal specifications were translated into B abstract machines. Test cases were generated via model checking with calculated trap properties from coverage criteria. Furthermore, we employed mutation analysis to evaluate the test suite. In this approach, the model-based test case generation and code-based evaluation techniques are independent of each other, which provides much more accurate measures of the testing results.Results: We applied our approach to a real-world case study of the Amazon E-Commerce Service (ECS). The experimental results have validated the effectiveness of the proposed solution.Conclusion: It is concluded that our approach is capable of automatically generating an effective set of test cases from the WSMO goal descriptions for SWS testing. The quality of test cases was measured in terms of their abilities to discover the injected faults at the code level. We implemented a tool to automate the steps for the mutation-based evaluation.

State Transition Based Test Model and Test Case Generation Technique for Embedded System: An Empirical Approach

Studies on the testing techniques required during process of black box testing in embedded system have been increasing tremendously. This paper suggests test model and test case generation method for model based testing of embedded system. Considering the complicated internal architecture and real-time characteristics of embedded system, test cases are generated by using the state based behavior modeling method. The proposed state transition model based test case generation method suggests systematic procedures ranged from the use case specification to the test case generation. Entire procedure of test case generation in MP3 player case which uses the suggested method is presented in this paper. With the created test cases, the interaction among the components of embedded system can be easily figured out, thereby helping easy error detection. Moreover, the test cases applied with characteristics and constraints of embedded system could be achieved by modeling system behavior using SysML.

Does this fault lead to failure? Combining refinement and input–output conformance checking in fault-oriented test-case generation

In this paper we describe an advanced test-case generation technique that is implemented in our model-based test-case generator MoMuT::UML. The tool injects faults into a UML model and analyses if the faults propagate to the interface. If a fault does propagate to an observable failure, an explaining sequence of events is generated and converted into a test-case scenario. The faults are detected using a highly optimised refinement checker, their propagation is analysed with an input–output conformance (ioco) checker. We show that this combination is faster than pure input–output conformance checking. It has been used in a recent industrial application of testing automotive measurement devices. The refinement and ioco checker are implemented in Prolog using the SMT solver Z3.

H-Switch Cover: a new test criterion to generate test case from finite state machines

Test cases generation based on Finite State Machines (FSMs) has been addressed for quite some time. Model-based testing has drawn attention from researchers and practitioners as one of the approaches to support software verification and validation. Several test criteria have been proposed in the literature to generate test cases based on formal methods, such as FSM. However, there is still a lot to be done on this aspect in order to clearly direct a test designer to choose a test criterion most suitable to generate test cases for a certain application domain. This work presents a new test criterion for model-based test case generation based on FSM, H-Switch Cover. H-Switch Cover relies on the traditional Switch Cover test criterion, but H-Switch Cover uses new heuristics to improve its performance, for example, adoption of rules to optimize graph balancing and traverse the graph for test cases generation. We conducted an investigation of cost and efficiency of this new test criterion by comparing it with unique input/output and distinguishing sequence. We used two embedded software products (space application software products) and mutation analysis for assessing efficiency. In general, for the case studies proposed in this paper in terms of cost (amount of events) and efficiency (mutation score), H-Switch Cover test criterion presented an average and a standard deviation better than the other two test criteria.

An Approach to Generating Test Data for EFSM Paths Considering Condition Coverage

Model-based test case generation has become a hotspot, and automatic generation of test data is difficult in this area. In this paper, system model is represented by extended finite state machine(EFSM), and genetic algorithm is used to generate test data for EFSM paths. When computing the fitness of an individual, the branch distance and the ratio of uncovered conditions of the individual are considered. In experiments, the proposed method is compared with the Kalaji's, and the results show that our method has a better effect and can get higher quality test data.

Model-based test generation using extended symbolic grammars

A novel, model-based test case generation approach for validating reactive systems, especially those supporting richly structured data inputs and/or interactions, is presented. Given an executable system model and an extended symbolic grammar specifying plausible system inputs, the approach performs a model-based simulation to (i) ensure the consistency of the model with respect to the specified inputs, and (ii) generate corresponding test cases for validating the system. The model-based simulation produces a state transition diagram (STD) automatically justifying the model runtime behaviors within the test case coverage. The STD can further be transformed to produce an evolved symbolic grammar, which can then be used to incrementally generate a refined set of test cases. As a case study, we present a live sequence chart (LSC) model-based test generator, named LCT in short, for LSC simulation and consistency testing. The evolved symbolic grammar produced by the simulator can either be used to generate practical test cases for software testing, or be further refined by applying our model-based test generation approach again with additional test coverage criteria. We further show that LSCs can also be used to specify and test certain temporal system properties during the model simulation. Their satisfaction, reflected in the STD, can either be served as a directive for selective test generation, or a basis for further temporal property model checking.

Model based Test Cases Generation for Web Applications

With the advent of web 2.0, web application architecture has changed a lot with increasing complexity. Modeling of the web applications has a key role in development; if modeling is inappropriate then the developed application will be poor. Testing is an important activity to improve the quality of web applications. So a technique for Model based Test case generation for Web applications have been proposed. Web Diagrams and Sequence Diagrams are used to model the behavior of web application under Test (AUT). Web diagram provides the functional requirement and sequence diagram provided the most important part of the web application, the Navigation between web pages. Navigation is the only thing that makes difference between stand alone applications and Web application. The proposed technique is validated with various case studies. General Terms Model based Testing, UML diagrams, Web Diagram, Sequence Diagram, Web Testing,

Tool support for generating model-based test cases via web

Testing activities play an important role in order to obtain high quality software products. These activities become more important when considering critical software, for instance, space application software. Nowadays, there is an extensive collaboration among space institutions. So, it is more than natural to expect distributed development of software and software testing activities. Therefore, a collaborative tool hosted on the internet becomes quite useful. In this respect, WEB-PerformCharts 2.0 tool discussed in this paper moves in this direction. The tool focuses on supporting a single aspect of distributed software development: the activity of generating test cases via web. Moreover, it allows model-based test case generation by means of formal methods formal languages statecharts and FSM which are considered state of the art in software development. WEB-PerformCharts 2.0 can be used to generate test cases for any kind of reactive systems modelled in statecharts or FSM. We present three case studies in different application domains to demonstrate the feasibility of our tool.

Model-Based Test Case Generation by Reusing Models From Runtime Monitoring of Deeply Embedded Systems

This letter introduces a novel application of model-based runtime monitoring of deeply embedded systems. The proposed framework comprises of a minimally intrusive, generic, software-based, runtime monitoring methodology for visualizing the behavior of deeply embedded systems in real-time. The model-based runtime monitoring results are then reused for generating model-based test cases. A prototype implementation of the proposed framework is discussed along with examples.