Interaction-based integration testing of component-based software systems

The code of JUnit test cases is commonly used to characterize software testing effort. Different metrics have been proposed in literature to measure various perspectives of the size of JUnit test cases. Unfortunately, there is little understanding of the empirical application of these metrics, particularly which metrics are more useful in terms of provided information. This paper aims at proposing a unified metrics suite that can be used to quantify the unit testing effort. We addressed the unit testing effort from the perspective of unit test case construction, and particularly the effort involved in writing the code of JUnit test cases. We used in our study five unit test case metrics, two of which were introduced in a previous work. We conducted an empirical study in three main stages. We collected data from six open source Java software systems, of different sizes and from different domains, for which JUnit test cases exist. We performed in a first stage a Principal Component Analysis to find whether the analyzed unit test case metrics are independent or are measuring similar structural aspects of the code of JUnit test cases. We used in a second stage clustering techniques to determine the unit test case metrics that are the less volatile, i.e. the least affected by the style adopted by developers while writing the code of test cases. We used in a third stage correlation and linear regression analysis to evaluate the relationships between the internal software class attributes and the test case metrics. The main goal of this study was to identify a subset of unit test case metrics: (1) providing useful information on the effort involved to write the code of JUnit test cases, (2) that are independent from each other, and (3) that are the less volatile. Results confirm the conclusions of our previous work and show, in addition, that: (1) the set of analyzed unit test case metrics could be reduced to a subset of two independent metrics maximizing the whole set of provided information, (2) these metrics are the less volatile, and (3) are also the most correlated to the internal software class attributes.

In this paper, we demonstrate a method that uses the model transformation technology of MDA to generate unit test cases from a platform-independent model of the system. The method we propose is based on sequence diagrams. First we model the sequence diagram and then this model is automatically transformed into a general unit test case model (an xUnit model which is independent of a particular unit testing framework), using model-to-model transformations. Then model-to-text transformations are applied on the xUnit model to generate platform- specific (JUnit, SUnit etc.) test cases that are concrete and executable. We have implemented the transformations in a prototype tool based on the Tefkat transformation tool and MOFScript. The paper gives details of the tool and the transformations that we have developed. We have applied the method to a small example (ATM simulation).

In the software industry, software testing becomes more important in the entire software development life cycle. Software testing is one of the fundamental components of software quality assurances. Software Testing Life Cycle (STLC)is a process involved in testing the complete software, which includes Regression Testing, Unit Testing, Smoke Testing, Integration Testing, Interface Testing, System Testing & etc. In the STLC of Regression testing, test case selection is one of the most important concerns for effective testing as well as cost of the testing process. During the Regression testing, executing all the test cases from existing test suite is not possible because that takes more time to test the modified software. This paper proposes new Hybrid approach that consists of modified Greedy approach for handling the test case selection and Genetic Algorithm uses effective parameter like Initial Population, Fitness Value, Test Case Combination, Test Case Crossover and Test Case Mutation for optimizing the tied test suite. By doing this, effective test cases are selected and minimized the tied test suite to reduce the cost of the testing process. Finally the result of proposed approach compared with conventional greedy approach and proved that our approach is more effective than other existing approach.

Microservices have been applied on several major systems including airlines. The characteristics of microservices which are independent and also interconnected need to be tested. The testing is done to preserve the system’s sequential stage processes, especially the online ticket reservation. Four features which are the search, booking, payment, and booking info feature are tested. This research performed three stages of testing on the microservices, those are unit testing, integrity testing, and end-to-end testing. Unit testing was conducted to test every function on every nodule, integrity testing was done to test interconnection between microservices, and end-to-end testing was to test the final results obtained after the unit test and integrity test were carried out. The three stages of testing must be done sequentially. The system on the airline provides the valid or correct response. Three stages of testing can be applied on other airlines by obtaining a legal API and can be accessed publicly.

Integration testing, a critical and resource-intensive phase in the software development lifecycle, can account for up to a high percentage of the total testing cost. Identifying classes with high coupling is crucial for efficient integration testing, as these classes are more susceptible to the impact of maintenance-related changes. This research introduces a novel metric called <i>combined structural and textual class coupling</i> (CSTCC), which harnesses the power of artificial intelligence (AI) techniques to predict and rank the most critical classes in an object-oriented software system. CSTCC integrates structural coupling metrics with <i>latent semantic indexing</i> (LSI)-based textual coupling, providing a comprehensive measure of class coupling. LSI, an information retrieval technique, analyses the semantic relationships between classes based on their textual content, enabling CSTCC to capture both structural and conceptual dependencies, resulting in a more accurate identification of high-risk classes. The effectiveness of the proposed approach is rigorously evaluated using mutation testing on four Java open-source projects, and the results demonstrate that test cases developed based on CSTCC achieve high mutation scores, indicating their ability to detect a significant percentage of integration faults. By focusing testing efforts on high-coupling classes identified by CSTCC, developers can potentially save time and cost during integration testing. The results demonstrate that test cases developed based on CSTCC achieve high mutation scores, ranging from 98% to 100%, indicating their ability to detect a significant percentage of integration faults. Additionally, the approach results in substantial efficiency gains, with a notable reduction in the number of test cases needed, saving up to 33.3% of the testing effort in some cases. By focusing testing efforts on high-coupling classes identified by CSTCC, developers can potentially save time and cost during integration testing. The CSTCC metric provides a novel and effective approach to prioritize testing resources and improve the efficiency of integration testing in object-oriented software systems.

Unit and integration tests can be invaluable during software maintenance as they help to understand pieces of code, they help with quality assurance and they build up confidence amongst developers. Unfortunately then, previous research has shown that unit tests do not always co-evolve nicely with the production code, thus leaving the software vulnerable. This paper presents TestNForce, a tool that helps developers to identify the unit tests that need to be altered and executed after a code change, thereby reducing the effort needed to keep the unit tests in sync with the changes to the production code. In order to evaluate TestNForce, we perform a user study that evaluates the adequacy, usefulness and completeness of TestNForce.

Increasing numbers of software developers are using the Unified Modeling Language (UML) and associated visual modeling tools as a basis for the design and implementation of their distributed, component-based applications. At the same time, it is necessary to test these components, especially during unit and integration testing. At Siemens Corporate Research, we have addressed the issue of testing components by integrating test generation and test execution technology with commercial UML modeling tools such as Rational Rose; the goal being a design-based testing environment. In order to generate test cases automatically, developers first define the dynamic behavior of their components via UML Statecharts, specify the interactions amongst them and finally annotate them with test requirements. Test cases are then derived from these annotated Statecharts using our test generation engine and executed with the help of our test execution tool. The latter tool was developed specifically for interfacing to components based on COM/DCOM and CORBA middleware. In this paper, we present our approach to modeling components and their interactions, describe how test cases are derived from these component models and then executed to verify their conformant behavior. We outline the implementation strategy of our TnT environment and use it to evaluate our approach by means of a simple example.

Unit testing has a significant role in software development and its impacts depend on the quality of test cases and test data used. To reduce time and effort, unit test generator systems can help automatically generate test cases and test data. However, there is currently no unit test generator for Kotlin programming language even though this language is popularly used for android application developments. In this study, we propose and develop a test generator system that utilizes genetic algorithm (GA) and ANTLR4 parser. GA is used to obtain the most optimal test cases and data for a given Kotlin code. ANTLR4 parser is used to optimize the mutation process in GA so that the mutation process is not totally random. Our model results showed that the average value of code coverage in generated unit tests against instruction coverage is 95.64%, with branch coverage of 76.19% and line coverage of 96.87%. In addition, only two out of eight generated classes produced duplicate test cases with a maximum of one duplication in each class. Therefore, it can be concluded that our optimization with GA on the unit test generator is able to produce unit tests with high code coverage and low duplication.

The several local wars that broke out at the turn of the century have shown to the world that the rapid development of high and new technology with information technology as the core is effectively promoting the pace of world military reform, and its most essential feature is information dominance. In local wars under modern high-tech conditions, rapid response and multiarms joint and coordinated operations have become the key factors to win, which requires multiarms, multiweapon platforms, and each combat unit software to work autonomously and dynamically. This research mainly discusses the dynamic posture prediction model in the informationized combat environment. It designs the organization of command elements, related data (products and tools), competency, personnel matching checklists, and activities in joint operational planning and relies on activities to model the binding of groups, capabilities, and related data. Finally, it forms process segments through the combined design of activities and then sets the final state and background knowledge constraints on the process segments to construct the process knowledge, turning each combat unit into an agent unit, so that the combat software unit has the performance characteristics of the agent’s autonomy, reactivity, and sociality. At the same time, it has good communication performance and autonomous negotiation ability, so it can realize the autonomous connection, communication, and cooperative work among multiagent systems. During the process execution or business processing, the seat staff can input the goal and background of the activity according to the current operating environment. It relies on the background constraints of the process knowledge to quickly match the corresponding process knowledge, insert the process fragments in the process knowledge into the original process, realize the rapid and efficient decomposition of the process redefinition, and effectively ensure the orderly development of the combat command. Techniques and methods for automating integration testing of combat systems are provided. These technologies are further applied to the process of combat system integration tests to improve the efficiency of combat system integration. In addition, through the research on the integration testing technology of combat systems, the problems of low generality of integration testing software and many structural repetitive codes can also be solved and the existing integration testing technology can be further improved. In the research, the time-consuming of the script interpretation module accounts for a relatively low proportion of about 5% of the simulation. The article embodies the platform to explore the realization of multiagent-based dynamic cooperative operations, to achieve the purpose of simulating the battlefield situation, rehearsing the combat plan, and evaluating the strike effect. This study will improve the efficiency of overall combat system integration.

Adaptive Random Testing (ART) aims to enhance the performance of pure random testing by detecting failure region in a software. The ART algorithm generates effective test cases which requires less number of test cases than that of pure random testing. However, all ART algorithms currently proposed are designed for the tests of monolithic system or unit level. In case of integrated system tests, ART approaches do not achieve same performances as those of ARTs applied to the unit or monolithic system. In this paper, we propose an extended ART algorithm which can be applied to the integrated system testing environment without degradation of performance. The proposed approach investigates an input distribution of the unit under a test with limited number of seed input data and generates information to be used to resizing input domain partitions. The simulation results show that our approach in an integration environment could achieve similar level of performance as an ART is applied to a unit testing. Results also show resilient effectiveness for various failure rates.

As a critical part of NASA's Evolutionary Xenon Thruster (NEXT) test validation process, a single string integration test was performed on the NEXT ion propulsion system. The objectives of this test were to verify that an integrated system of major NEXT ion propulsion system elements meets project requirements, to demonstrate that the integrated system is functional across the entire power processor and xenon propellant management system input ranges, and to demonstrate to potential users that the NEXT propulsion system is ready for transition to flight. Propulsion system elements included in this system integration test were an engineering model ion thruster, an engineering model propellant management system, an engineering model power processor unit, and a digital control interface unit simulator that acted as a test console. Project requirements that were verified during this system integration test included individual element requirements ; integrated system requirements, and fault handling. This paper will present the results of these tests, which include: integrated ion propulsion system demonstrations of performance, functionality and fault handling; a thruster re-performance acceptance test to establish baseline performance: a risk-reduction PMS-thruster integration test: and propellant management system calibration checks.

Integration testing has always been a challenge especially if the system under test is large with many subsystems and interfaces. This paper proposes an approach to design End-to-End (E2E) integration testing, including test scenario specification, test case generation and tool support. Test scenarios are specified as thin threads, each of which represents a single function from an end user's point of view. Thin threads can be organized hierarchically into a tree with each branch consisting of a set of related thin threads representing a set of related functionality. A test engineer can use thin-thread trees to generate test cases systematically, as well as carry out other related tasks such as risk analysis and assignment, regression testing, ripple effect analysis. A prototype tool has been developed to support E2E testing in a distributed environment on the J2EE platform.

This article describes a flexible approach for integration testing based on business processes. The approach was successfully implemented in medium, large and very large projects in large organisations of different industries. In this approach the tester defines test cases for the functions of a business process. The test cases are then linked together to form test case sequences. Each test case sequence tests a certain path through a business process. The approach supports various testing strategies for applications in a time-constrained project environment. A testing strategy with business-oriented integration testing as its focal point can quickly deliver a picture of an application's overall quality as well as point out areas where more detailed and intensive testing is needed. The test approach is tool-supported.

Software product line (SPL) testing is a challenging task, due to the huge number of variants sharing common functionalities to be taken into account for efficient testing. By adopting the concept of regression testing, incremental SPL testing strategies cope with this challenge by exploiting the reuse potential of test artifacts between subsequent variants under test. In previous work, we proposed delta-oriented test case prioritization for incremental SPL integration testing, where differences between architecture test model variants allow for reasoning about the order of reusable test cases to be executed. However, the prioritization left two issues open, namely (1) changes to component behavior are ignored, which may also influence component interactions and, (2) the weighting and ordering of similar test cases result in an unintended clustering of test cases. In this paper, we extend the test case prioritization technique by (1) incorporating changes to component behavior allowing for a more fine-grained analysis and (2) defining a dissimilarity measure to avoid clustered test case orders. We prototyped our test case prioritization technique and evaluated its applicability and effectiveness by means of a case study from the automotive domain showing positive results.

Identification of fuel cycle simulator functionalities for analysis of transition to a new fuel cycle