A subset of precise UML for Model-based Testing

This paper presents an original model-based testing approach that takes a UML behavioural view of the system under test and automatically generates test cases and executable test scripts according to model coverage criteria. This approach is embedded in the LEIRIOS Test Designer tool and is currently deployed in domains such as Enterprise IT and electronic transaction applications. This model-based testing approach makes it possible to automatically produce the traceability matrix from requirements to test cases as part of the test generation process. This paper defines the subset of UML used for model-based testing and illustrates it using a small example

Automated Functional Testing based on the Navigation of Web Applications

Web applications are becoming more and more complex. Testing such applications is an intricate hard and time-consuming activity. Therefore, testing is often poorly performed or skipped by practitioners. Test automation can help to avoid this situation. Hence, this paper presents a novel approach to perform automated software testing for web applications based on its navigation. On the one hand, web navigation is the process of traversing a web application using a browser. On the other hand, functional requirements are actions that an application must do. Therefore, the evaluation of the correct navigation of web applications results in the assessment of the specified functional requirements. The proposed method to perform the automation is done in four levels: test case generation, test data derivation, test case execution, and test case reporting. This method is driven by three kinds of inputs: i) UML models; ii) Selenium scripts; iii) XML files. We have implemented our approach in an open-source testing framework named Automatic Testing Platform. The validation of this work has been carried out by means of a case study, in which the target is a real invoice management system developed using a model-driven approach.Comment: In Proceedings WWV 2011, arXiv:1108.208

Test Case Optimization and Redundancy Reduction Using GA and Neural Networks

More than 50% of software development effort is spent in testing phase in a typical software development project. Test case design as well as execution consume a lot of time. Hence, automated generation of test cases is highly required. Here a novel testing methodology is being presented to test object-oriented software based on UML state chart diagrams. In this approach, function minimization technique is being applied and generate test cases automatically from UML state chart diagrams. Software testing forms an integral part of the software development life cycle. Since the objective of testing is to ensure the conformity of an application to its specification, a test “oracle” is needed to determine whether a given test case exposes a fault or not. An automated oracle to support the activities of human testers can reduce the actual cost of the testing process and the related maintenance costs. In this paper, a new concept is being presented using an UML state chart diagram and tables for the test case generation, artificial neural network as an optimization tool for reducing the redundancy in the test case generated using the genetic algorithm. A neural network is trained by the back-propagation algorithm on a set of test cases applied to the original version of the system

UUM Library Mobile-Based Book Reservation System

Reserving a book online is the newest facility developed in most libraries all around the world. In reserving books from the library, students have to access the UUM library website. Therefore, students must have a PC, laptop or similar device that can access the Internet. However, not all students have their own PC, laptop or PDA to access the Internet from wherever and whenever they wish. This paper attempts to design a Mobile-based Book Reservation System, as well as a new mobile system that can be used by UUM students to check the availability of books and to make reservation for the required books from wherever they are or whenever they want. UML is used as the modeling language for the design of the system, usability testing is included, system development life cycle is used for planning and analysis of the project and UML approach is used to design the system. The last section highlights few limitations that could be considered for future work

An automated test case generating tool using UML activity diagram

Software or application testing is a process of executing a program with the goal of finding defect to make better system. In software testing phase, writing test cases is one of the important activities. Manually writing test cases approach is lengthy of time period and need more effort to accomplish the process. On the other hand, automated test case generation technique is the way to solve this issue and model-based test case generation approach would be the appropriate for this automation process. Usually, a model is required in model-based testing approach to generate the test cases and UML activity diagram is the model in our research. In this paper, we explained our proposed model-based test case generating approach and we successfully developed a tool based on our proposed technique that could generate test cases automatically using UML activity diagram as an input. Finally, we conducted an experiment on a real life simple application of a system using the tool and successfully able to show that our tool can produce same test cases as manually writing test cases of the same system but this tool can save a lot of time and effort as well

UML approach to the generation of test sequences for Java-based concurrent systems

Starting with a UML specification that captures the underlying functionality of some given Java-based concurrent system, we describe a systematic way to construct, from this specification, test sequences for validating an implementation of the system. The approach is to first extend the specification to create UML state machines that directly address those aspects of the system we wish to test. To be specific, the extended UML state machines can capture state information about the number of waiting threads or the number of threads blocked on a given object. Using the SAL model checker we can generate from the extended UML state machines sequences that cover all the various possibilities of events and states. These sequences can then be directly transformed into test sequences suitable for input into a testing tool such as ConAn. As an illustration, the methodology is applied to generate sequences for testing a Java implementation of the producer-consumer system. © 2005 IEE

Model based test suite minimization using metaheuristics

Software testing is one of the most widely used methods for quality assurance and fault detection purposes. However, it is one of the most expensive, tedious and time consuming activities in software development life cycle. Code-based and specification-based testing has been going on for almost four decades. Model-based testing (MBT) is a relatively new approach to software testing where the software models as opposed to other artifacts (i.e. source code) are used as primary source of test cases. Models are simplified representation of a software system and are cheaper to execute than the original or deployed system. The main objective of the research presented in this thesis is the development of a framework for improving the efficiency and effectiveness of test suites generated from UML models. It focuses on three activities: transformation of Activity Diagram (AD) model into Colored Petri Net (CPN) model, generation and evaluation of AD based test suite and optimization of AD based test suite. Unified Modeling Language (UML) is a de facto standard for software system analysis and design. UML models can be categorized into structural and behavioral models. AD is a behavioral type of UML model and since major revision in UML version 2.x it has a new Petri Nets like semantics. It has wide application scope including embedded, workflow and web-service systems. For this reason this thesis concentrates on AD models. Informal semantics of UML generally and AD specially is a major challenge in the development of UML based verification and validation tools. One solution to this challenge is transforming a UML model into an executable formal model. In the thesis, a three step transformation methodology is proposed for resolving ambiguities in an AD model and then transforming it into a CPN representation which is a well known formal language with extensive tool support. Test case generation is one of the most critical and labor intensive activities in testing processes. The flow oriented semantic of AD suits modeling both sequential and concurrent systems. The thesis presented a novel technique to generate test cases from AD using a stochastic algorithm. In order to determine if the generated test suite is adequate, two test suite adequacy analysis techniques based on structural coverage and mutation have been proposed. In terms of structural coverage, two separate coverage criteria are also proposed to evaluate the adequacy of the test suite from both perspectives, sequential and concurrent. Mutation analysis is a fault-based technique to determine if the test suite is adequate for detecting particular types of faults. Four categories of mutation operators are defined to seed specific faults into the mutant model. Another focus of thesis is to improve the test suite efficiency without compromising its effectiveness. One way of achieving this is identifying and removing the redundant test cases. It has been shown that the test suite minimization by removing redundant test cases is a combinatorial optimization problem. An evolutionary computation based test suite minimization technique is developed to address the test suite minimization problem and its performance is empirically compared with other well known heuristic algorithms. Additionally, statistical analysis is performed to characterize the fitness landscape of test suite minimization problems. The proposed test suite minimization solution is extended to include multi-objective minimization. As the redundancy is contextual, different criteria and their combination can significantly change the solution test suite. Therefore, the last part of the thesis describes an investigation into multi-objective test suite minimization and optimization algorithms. The proposed framework is demonstrated and evaluated using prototype tools and case study models. Empirical results have shown that the techniques developed within the framework are effective in model based test suite generation and optimizatio

Rancang Bangun Sistem Informasi Audit Mutu Internal

Internal quality audits are conducted within the internal quality assurance system (SPMI) of higher education institutions to ensure compliance with SPMI standards and enhance a quality culture. Constraints in implementing internal quality audits include limitations in human resources, time, and costs, as well as the complexity of audit stages and documentation of audit findings. To address these challenges, a website-based information system has been designed using the waterfall method and the Unified Modeling Language (UML) approach, utilizing the PHP framework CodeIgniter and a MySQL database. The system aims to digitize and automate the implementation of internal quality audits to enhance effectiveness and efficiency. Additionally, it facilitates the management and storage of internal quality audit documents. For testing purposes, black-box testing is employed, consisting of 10 different test types. The testing results indicate a 90% success rate, while 10% of the data did not succeed due to the limitation of inputting text HTML

Supporting inheritance hierarchy changes in model-based regression test selection

Models can be used to ease and manage the development, evolution, and runtime adaptation of a software system. When models are adapted, the resulting models must be rigorously tested. Apart from adding new test cases, it is also important to perform regression testing to ensure that the evolution or adaptation did not break existing functionality. Since regression testing is performed with limited resources and under time constraints, regression test selection (RTS) techniques are needed to reduce the cost of regression testing. Applying model-level RTS for model-based evolution and adaptation is more convenient than using code-level RTS because the test selection process happens at the same level of abstraction as that of evolution and adaptation. In earlier work, we proposed a model-based RTS approach called MaRTS to be used with a fine-grained model-based adaptation framework that targets applications implemented in Java. MaRTS uses UML models consisting of class and activity diagrams. It classifies test cases as obsolete, reusable, or retestable based on changes made to UML class and activity diagrams of the system being adapted. However, MaRTS did not take into account the changes made to the inheritance hierarchy in the class diagram and the impact of these changes on the selection of test cases. This paper extends MaRTS to support such changes, and demonstrates that the extended approach performs as well as or better than code-based RTS approaches in safely selecting regression test cases. While MaRTS can generally be used during any model-driven development or model-based evolution activity, we have developed it in the context of runtime adaptation. We evaluated the extended MaRTS on a set of applications, and compared the results with code-based RTS approaches that also support changes to the inheritance hierarchy. The results showed that the extended MaRTS selected all the test cases relevant to the inheritance hierarchy changes, and that the fault detection ability of the selected test cases was never lower than that of the baseline test cases. The extended MaRTS achieved comparable results to a graph-walk code-based RTS approach (DejaVu), and showed a higher reduction in the number of selected test cases when compared with a static analysis code-based RTS approach (ChEOPSJ)

Test Case Generation From UML Interaction Overview Diagram and Sequence Diagram

The most important part of the testing attempts is the test case generation. Unified modeling language(UML) is the most generally used to describe design specification and analysis by both academic and industry. UML models offer a lot of information that should not be ignored in testing. Testing of software is a time-consuming activity which requires a great deal of planning and resources. In scenario-based testing, test scenarios are used for generating test cases, test drivers etc. By combining different UML components, different views of the program under test are used. UML provides the capability to enhance (explore) the static structure and dynamic behavior of a software system. Different UML strategies and techniques are implemented during the whole software development life cycle. Therefore UML becomes the source of test case generation. The main problems in testing object oriented programs is test case selection, it is impossible to stimulate the program with all data of the input domain. A pragmatic approach is to concentrate on typical message sequences as modled using the sequence diagram. Testing based on sequence diagrams seems to be intuitive. Each sequence diagram specifies one test case or set of test cases. We proposed a method generate test cases using Interaction Overview diagram and sequence diagram. Our work considers interaction operators of UML 2.0 Sequence diagram like alt , loop par to generate test cases. First we construct the SD and Interaction Overview diagram for the given problem .After this we generate XMI code for these diagram using magic draw software ,its generate ID’s of all nodes and all paths. Then we developed an intermediate graph, named UML in- teraction graph(UIG) and message dependency graph of sequence diagram. From the generated UIG, we generate different case, for represent different scenarios