Unit Test Cases Research Articles

Automated testing for Java programs using JPF-based test case generation

Program testing requires a series of tasks such as preparing drivers and stubs, creating test cases, and executing unit tests. To reduce manual effort of performing such tasks for testing Java programs, we developed a tool that fully integrates and automates all of these processes, by using JPF with extensions as a symbolic execution engine for automatically generating unit test cases. In this paper, we present this tool and its application to real projects to evaluate its efficacy. The evaluation results demonstrate that the tool performs well in terms of the test time reduction compared with manual test as it eliminates the total amount of manual effort, while largely preserving a high coverage of greater than 90 % as our expected borderline.

An Integration Testing Approach Based on Composition of Unit Test Cases

Assembling unit models to perform integration testing often lead to both state explosion and the repeated work of unit testing. To mitigate the above crux, we present a novel integration testing approach, which derives integration test cases from the composition of unit test cases instead of unit models. Thus, the integration testing is performed efficiently and the difficulties of model combination are alleviated. The results of case study show that the proposed method not only bears the equal fault-detecting ability with low computational complexity, but also offers more generality compared with the model assemble-based method; therefore the development cost could be reduced

Integration testing through reusing representative unit test cases for high-confidence medical software

As medical software is getting larger-sized, complex, and connected with other devices, finding faults in integrated software modules gets more difficult and time consuming. Existing integration testing typically takes a black-box approach, which treats the target software as a black box and selects test cases without considering internal behavior of each software module. Though it could be cost-effective, this black-box approach cannot thoroughly test interaction behavior among integrated modules and might leave critical faults undetected, which should not happen in safety-critical systems such as medical software. This work anticipates that information on internal behavior is necessary even for integration testing to define thorough test cases for critical software and proposes a new integration testing method by reusing test cases used for unit testing. The goal is to provide a cost-effective method to detect subtle interaction faults at the integration testing phase by reusing the knowledge obtained from unit testing phase. The suggested approach notes that the test cases for the unit testing include knowledge on internal behavior of each unit and extracts test cases for the integration testing from the test cases for the unit testing for a given test criteria. The extracted representative test cases are connected with functions under test using the state domain and a single test sequence to cover the test cases is produced. By means of reusing unit test cases, the tester has effective test cases to examine diverse execution paths and find interaction faults without analyzing complex modules. The produced test sequence can have test coverage as high as the unit testing coverage and its length is close to the length of optimal test sequences.

Unit Test Case Selection to Evaluate Changes in Critical Time

Defects blocking major business transactions may be found while a software system is in production. Due to the urgency of returning the system to proper operation, these defects are frequently resolved in the production environment itself, under such a restricted deadline that there is not enough time to run the complete set of unit test cases upon the patched version of the software. Declining to run the test case suite allows quicker deployment to production, but also allows for other defects to be introduced into the system. This paper evaluates whether a heuristic search approach can help a decision-maker selecting a subset of a unit test case suite to validate a set of changes made in the production environment. The selected test cases should maximize the coverage of changed features and must be executed under a strict time constraint. We designed and executed an experiment which compared different algorithms and found that heuristic search can provide better solutions to this test case selection problem (though at higher cost) than local or random search when the time restriction is a small fraction of the time required to run the full suite.

A Function Interaction Testing by Reusing Characterized Test Cases

This letter proposes a reuse method of unit test cases, which characterize internal behaviors of a called function, for enhancing capability of automatic generation of test cases. Existing test case generation tools have limits in finding solutions to the deep call structure of the source code. In our approach, the complex call structure is simplified by reusing unit test cases of called functions. As unit test cases represent the characteristics of the called function, the internal behaviors of called functions are replaced by the test cases. This approach can be applicable to existing test tools for simplifying the process of generation and enhancing their capabilities.

Data clustering in C++: an object-oriented approach

Data clustering is a highly interdisciplinary field, the goal of which is to divide a set of objects into homogeneous groups such that objects in the same group are similar and objects in different groups are quite distinct. Thousands of theoretical papers and a number of books on data clustering have been published over the past 50 years. However, few books exist to teach people how to implement data clustering algorithms. This book was written for anyone who wants to implement or improve their data clustering algorithms. Using object-oriented design and programming techniques, Data Clustering in C++ exploits the commonalities of all data clustering algorithms to create a flexible set of reusable classes that simplifies the implementation of any data clustering algorithm. Readers can follow the development of the base data clustering classes and several popular data clustering algorithms. Additional topics such as data pre-processing, data visualization, cluster visualization, and cluster interpretation are briefly covered. This book is divided into three parts-- Data Clustering and C++ Preliminaries: A review of basic concepts of data clustering, the unified modeling language, object-oriented programming in C++, and design patterns A C++ Data Clustering Framework: The development of data clustering base classes Data Clustering Algorithms: The implementation of several popular data clustering algorithms A key to learning a clustering algorithm is to implement and experiment the clustering algorithm. Complete listings of classes, examples, unit test cases, and GNU configuration files are included in the appendices of this book as well as in the CD-ROM of the book. The only requirements to compile the code are a modern C++ compiler and the Boost C++ libraries.

A New Approach : Software Development And Validation

For safety and effectiveness, the U.S. Food and Drug Administration (FDA) requires that software must be validated in the medical device industry. The software includes programs that are embedded in instruments and used in production/manufacturing process control, in which programmable logic controllers (PLCs) are widely used. The development and validation of a PLC program generally involves establishing software design (SD) structure, defining software requirements specification (SRS), conducting hazard analysis (HA), coding, and testing. The tasks are best accomplished through team efforts, with members taking the lead in activities suited to their skills within an organization; for example, SRS from the operation and the quality assurance (QA) departments; HA from emergency, health and safety (EHS); and coding from engineering. An integrated approach to these tasks would help a software project manager coordinate the team efforts effectively. This article describes an integrated approach to software development and validation in PLC programming. In this approach, the software development and validation start by establishing a normalized SD structure. This normalized structure is then incorporated into a traceability matrix (TM) of the SRS, into modules of program, and into test logs—such that every item defined in SRS or HA is registered in the normalized SRS TM table, coded in the normalized modules, tested, and documented in the normalized test logs. As the software system has a normalized structure, it becomes easy for different team members to define, review, code, test, document, and approve the relevant tasks within the software development and validation lifecycle.

UML‐based regression testing for OO software

AbstractIn software maintenance, a system has to be regression tested after modifying it. The goal of regression testing is to ensure that modifications have not adversely affected the system. Regression test selection determines a subset of test cases, from the initial test suite, which concentrates on the parts of the system affected by the modification. Previous techniques have been mainly code‐based and several of them have addressed procedural programs. When working with large and complex object‐oriented systems, source code‐based regression testing is usually costly. This paper proposes a programming‐language‐independent technique for regression test selection for object‐oriented software based on Unified Modeling Language (UML 2.0) design diagrams. These diagrams are: the newly introduced interaction overview diagram, class diagrams, and sequence diagrams. We assume a test suite that contains both unit and system test cases. Based on the software changes reflected in the class and the interaction overview diagrams, our proposed technique selects test cases in phases. In the first phase, we select both unit and system test cases that directly traverse the changed methods and their calling methods. For the second phase, we present algorithms for detecting system level changes in the interaction overview diagram. If the change is at the action level, which is represented by a sequence diagram, only the test cases that execute changed methods will be selected. We apply our proposed technique to a few object‐oriented subject applications and evaluate its precision and inclusiveness in addition to the number of selected tests; the results demonstrate the advantages of the technique. Copyright © 2010 John Wiley & Sons, Ltd.

Architecting Fault Tolerance with Exception Handling: Verification and Validation

When building dependable systems by integrating untrusted software components that were not originally designed to interact with each other, it is likely the occurrence of architectural mismatches related to assumptions in their failure behaviour. These mismatches, if not prevented during system design, have to be tolerated during runtime. This paper presents an architectural abstraction based on exception handling for structuring fault-tolerant software systems. This abstraction comprises several components and connectors that promote an existing untrusted software element into an idealised fault-tolerant architectural element. Moreover, it is considered in the context of a rigorous software development approach based on formal methods for representing the structure and behaviour of the software architecture. The proposed approach relies on a formal specification and verification for analysing exception propagation, and verifying important dependability properties, such as deadlock freedom, and scenarios of architectural reconfiguration. The formal models are automatically generated using model transformation from UML diagrams: component diagram representing the system structure, and sequence diagrams representing the system behaviour. Finally, the formal models are also used for generating unit and integration test cases that are used for assessing the correctness of the source code. The feasibility of the proposed architectural approach was evaluated on an embedded critical case study.

Carving and Replaying Differential Unit Test Cases from System Test Cases

Unit test cases are focused and efficient. System tests are effective at exercising complex usage patterns. Differential unit tests (DUT) are a hybrid of unit and system tests that exploits their strengths. They are generated by carving the system components, while executing a system test case, that influence the behavior of the target unit, and then re-assembling those components so that the unit can be exercised as it was by the system test. In this paper we show that DUTs retain some of the advantages of unit tests, can be automatically generated, and have the potential for revealing faults related to intricate system executions. We present a framework for carving and replaying DUTs that accounts for a wide variety of strategies and tradeoffs, we implement an automated instance of the framework with several techniques to mitigate test cost and enhance flexibility and robustness, and we empirically assess the efficacy of carving and replaying DUTs on three software artifacts.

단위테스트를 위한 레거시소프트웨어시스템의 재구성 기법

레거시소프트웨어시스템을 유지 및 보수하는 작업은 소프트웨어 공학 분야에서 중요한 화두이다. 그리고 유지 및 보수 과정에 있어 회귀 테스트는 소프트웨어의 변경에 따른 기능적 동작이 올바른지 확인한다. 그러나 기존의 회귀 테스트는 대부분 시스템 레벨에서 접근이 되었으며 단위테스트 레벨에서는 준비된 테스트 케이스가 없어서 적용이 어려웠다. 본 논문에서는 단위테스트 케이스들을 구현하고 자산화하기 위해서 기존의 레거시소프트웨어시스템을 재구성하는 기법을 제안한다. 그리고 이를 실제 개발 과제의 특정 모듈에 적용하고 그 테스트 커버리지 결과를 분석하였다. 향후 본 논문에서 제시하는 방안을 기반으로 재구성 자동화 기법 및 테스트 케이스 자동화 생성에 대한 연구가 지속된다면 레거시소프트웨어시스템의 유지 및 보수에 큰 발전을 기대할 수 있을 것이다. The maintenance of legacy software systems is very important in the field of a software engineering. In the maintenance, a regression test confirms the behavior preserving of the software which has been changed but most of regression tests are done in a system level and rarely done in a unit test level because there is no test case. This paper proposes how to modify legacy software systems and make unit test cases as an asset. It uses a technique with a specific module of a real software development project and analyzes test coverage results. After this, if a study about automatic restructuring techniques and a test case generation proceeds continuously, we can expect the big advance of legacy software systems maintenance.

An adaptive and trustworthy software testing framework on the grid

Grid computing, which is characterized by large-scale sharing and collaboration of dynamic distributed resources has quickly become a mainstream technology in distributed computing and is changing the traditional way of software development. In this article, we present a grid-based software testing framework for unit and integration test, which takes advantage of the large-scale and cost-efficient computational grid resources to establish a testbed for supporting automated software test in complex software applications. Within this software testing framework, a dynamic bag-of-tasks model using swarm intelligence is developed to adaptively schedule unit test cases. Various high-confidence computing mechanisms, such as redundancy, intermediate value checks, verification code injection, and consistency checks are employed to verify the correctness of each test case execution on the grid. Grid workflow is used to coordinate various test units for integration test. Overall, we expect that the grid-based software testing framework can provide efficient and trustworthy services to significantly accelerate the testing process with large-scale software testing.

Test-Driven Modeling for Model-Driven Development

A new software development process called test-driven modeling applies the Extreme Programming test-driven paradigm in a model-driven development environment. (The basis of this article is a project in Motorola's iDEN division that is extending and migrating a large legacy telecommunication system to new platforms using TDM.) This process involves automatic testing through simulation and using executable models as living software system architecture documents. In TDM, we use the same message sequence charts (MSCs) for both system analysis (or design documents) and unit test cases. Similarly, we use the same high-level modeling diagrams for both automatic code generation and living software architecture documents to guide the system's detailed implementation in later phases. Practical results show that developers can effectively apply TDM to large projects with high productivity and quality in terms of the number of code defects.

A structured experiment of test-driven development

Test Driven Development (TDD) is a software development practice in which unit test cases are incrementally written prior to code implementation. We ran a set of structured experiments with 24 professional pair programmers. One group developed a small Java program using TDD while the other (control group), used a waterfall-like approach. Experimental results, subject to external validity concerns, tend to indicate that TDD programmers produce higher quality code because they passed 18% more functional black-box test cases. However, the TDD programmers took 16% more time. Statistical analysis of the results showed that a moderate statistical correlation existed between time spent and the resulting quality. Lastly, the programmers in the control group often did not write the required automated test cases after completing their code. Hence it could be perceived that waterfall-like approaches do not encourage adequate testing. This intuitive observation supports the perception that TDD has the potential for increasing the level of unit testing in the software industry.