Phillip Laplante

Fevzi Belli

Jerry Gao

Greg Kapfhammer

Keith Miller

W. Eric Wong

Dianxiang Xu

Software Test Automation

The objective of this industry study is to shed light on the current situation and improvement needs in software test automation. To this end, 55 industry specialists from 31 organizational units were interviewed. In parallel with the survey, a qualitative study was conducted in 12 selected software development organizations. The results indicated that the software testing processes usually follow systematic methods to a large degree, and have only little immediate or critical requirements for resources. Based on the results, the testing processes have approximately three fourths of the resources they need, and have access to a limited, but usually sufficient, group of testing tools. As for the test automation, the situation is not as straightforward: based on our study, the applicability of test automation is still limited and its adaptation to testing contains practical difficulties in usability. In this study, we analyze and discuss these limitations and difficulties.

Jussi Kasurinen

Ossi Taipale

Kari Smolander

Software Test Automation in Practice: Empirical Observations

We propose a novel strategy to optimize the test suite required for testing both hardware and software in a production line. Here, the strategy is based on two processes: Quality Signing Process and Quality Verification Process, respectively. Unlike earlier work, the proposed strategy is based on integration of black box and white box techniques in order to derive an optimum test suite during the Quality Signing Process. In this case, the generated optimal test suite significantly improves the Quality Verification Process. Considering both processes, the novelty of the proposed strategy is the fact that the optimization and reduction of test suite is performed by selecting only mutant killing test cases from cumulating t-way test cases. As such, the proposed strategy can potentially enhance the quality of product with minimal cost in terms of overall resource usage and time execution. As a case study, this paper describes the step-by-step application of the strategy for testing a 4-bit Magnitude Comparator Integrated
Circuits in a production line. Comparatively, our result demonstrates that the proposed strategy outperforms the traditional block partitioning strategy with the mutant score of 100% to 90%, respectively, with the same number of test cases.

Mohammed I. Younis

Kamal Z. Zamli

A Strategy for Automatic Quality Signing and Verification Processes for Hardware and Software Testing

Modifications in software can affect some functionality that had been working until that point. In order to detect such a problem, the ideal solution would be testing the whole system once again, but there may be insufficient time or resources for this approach. An alternative solution is to order the test cases so that the most beneficial tests are executed first, in such a way only a subset of the test cases can be executed with little lost of effectiveness. Such a technique is known as regression test case prioritization. In this paper, we propose the use of the Reactive GRASP metaheuristic to prioritize test cases. We also compare this metaheuristic with other search-based algorithms previously described in literature. Five programs were used in the experiments. The experimental results demonstrated good coverage performance with some time overhead for the proposed technique. It also demonstrated a high stability of the results generated by the proposed approach.

Camila Loiola Brito Maia

Rafael Augusto Ferreira do Carmo

Fabr&#237;cio Gomes de Freitas

Gustavo Augusto Lima de Campos

Jerffeson Teixeira de Souza

Automated Test Case Prioritization with Reactive GRASP

Test redundancy detection reduces test maintenance costs  and also ensures the integrity of test suites. One of the most widely used approaches for this purpose is based on coverage information. In a recent work, we have shown that although this information can be useful in detecting redundant tests, it may suffer from large number of false-positive errors, that is, a test case being identified as redundant while it is really not. In this paper, we propose a semiautomated methodology to derive a reduced test suite from a given test suite, while keeping the fault detection effectiveness unchanged. To evaluate the methodology, we apply the mutation analysis technique to measure the fault detection effectiveness of the reduced test suite of a real Java project. The results confirm that the proposed manual interactive inspection process leads to a reduced test suite with the same fault detection ability as the original test suite.

Negar Koochakzadeh

Vahid Garousi

A Tester-Assisted Methodology for Test Redundancy Detection

This paper describes AnnaBot, one of the first tools to verify correct use of Annotation-based metadata in the Java
programming language. These Annotations are a standard Java 5 mechanism used to attach metadata to types, methods, or fields without using an external configuration file. A binary representation of the Annotation becomes part of the compiled “.class” file,
for inspection by another component or library at runtime. Java Annotations were introduced into the Java language in 2004 and have become widely used in recent years due to their introduction in the Java Enterprise Edition 5, the Hibernate object-relational mapping API, the Spring Framework, and elsewhere. Despite that, mainstream development tools have not yet produced a widely-used verification tool to confirm correct configuration and placement of annotations external to the particular runtime component. While most of the examples in this paper use the Java Persistence API, AnnaBot is capable of verifying anyannotation-based API for which “claims”—description of annotation
usage—are available. These claims can be written in Java or using a proposed Domain-Specific Language, which has been designed and a parser (but not the code generator) have been written.

Ian Darwin

AnnaBot: A Static Verifier for Java Annotation Usage

This paper presents a new approach to automatically generate GUI test
cases and validation points from a set of annotated use cases. This technique helps to reduce the effort required in GUI modeling and test coverage analysis during the software testing process. The test case generation process described in this paper is initially guided by use cases describing the GUI behavior, recorded as a set of interactions with the GUI elements (e.g., widgets being clicked, data input, etc.). These use cases (modeled as a set of initial test cases) are annotated by the tester to indicate interesting variations in widget values (ranges, valid or invalid values) and validation rules with expected results. Once the use cases are annotated, this approach uses the new defined values and validation rules to automatically generate new test cases and validation points, easily expanding the test coverage. Also, the process allows narrowing the GUI model testing to precisely identify the set of GUI elements, interactions, and values the tester is interested in.

Pedro Luis Mateo Navarro

Diego Sevilla Ruiz

Gregorio Mart&#237;nez P&#233;rez

A Proposal for Automatic Testing of GUIs Based on Annotated Use Cases

Estimating software development effort is an important task in the management of large software projects. The task is challenging, and it has been receiving the attentions of researchers ever since software was developed for commercial purpose. A number of estimation models exist for effort prediction. However, there is a need for novel models to obtain more accurate estimations. The primary purpose of this study is to propose a precise method of estimation by selecting the most popular models in order to improve accuracy. Consequently, the final results are very precise and reliable when they are applied to a real dataset in a software project. Empirical validation of this approach uses the International Software Benchmarking Standards Group (ISBSG) Data Repository Version 10 to demonstrate the improvement in software estimation accuracy.

Luiz Fernando Capretz

Venus Marza

Improving Effort Estimation by Voting Software Estimation Models

UML-RT is a UML real-time profile that allows modeling event-driven and distributed systems; however it is not a formal specification language. This paper proposes a formal approach for UML-RT through a mapping of the UML-RT communicating elements into the <svg style="vertical-align:-0.16302pt;width:9.625px;" id="M1" height="7.0124998" version="1.1" viewBox="0 0 9.625 7.0124998" width="9.625"  xmlns="http://www.w3.org/2000/svg">
	<g transform="matrix(1.25,0,0,-1.25,0,7.0125)">
		<g transform="translate(72,-66.39)">
			<text transform="matrix(1,0,0,-1,-71.95,66.6)">
				<tspan style="font-size: 12.50px; " x="0" y="0">𝜋</tspan>
			</text>

		</g>
	</g>
</svg>-calculus (or pi-calculus) process algebra. The formal approach both captures the intended behavior of the system being modeled and provides a rigorous and nonambiguous system description. Our proposal differentiates from other research work because we map UML-RT to <svg style="vertical-align:-0.16302pt;width:9.625px;" id="M2" height="7.0124998" version="1.1" viewBox="0 0 9.625 7.0124998" width="9.625"  xmlns="http://www.w3.org/2000/svg">
	<g transform="matrix(1.25,0,0,-1.25,0,7.0125)">
		<g transform="translate(72,-66.39)">
			<text transform="matrix(1,0,0,-1,-71.95,66.6)">
				<tspan style="font-size: 12.50px; " x="0" y="0">𝜋</tspan>
			</text>

		</g>
	</g>
</svg>-calculus, and we allow the mapping of dynamic reconfiguration of UML-RT unwired ports. We illustrate the usage and applicability of the mapping through three examples. The first example focuses on explaining the mapping; the second one aims to demonstrate the use of the <svg style="vertical-align:-0.16302pt;width:9.625px;" id="M3" height="7.0124998" version="1.1" viewBox="0 0 9.625 7.0124998" width="9.625"  xmlns="http://www.w3.org/2000/svg">
	<g transform="matrix(1.25,0,0,-1.25,0,7.0125)">
		<g transform="translate(72,-66.39)">
			<text transform="matrix(1,0,0,-1,-71.95,66.6)">
				<tspan style="font-size: 12.50px; " x="0" y="0">𝜋</tspan>
			</text>

		</g>
	</g>
</svg>-calculus definitions to verify system requirements; the third case is an example of mobile processes called Handover protocol.

J. M. Bezerra

C. M. Hirata

A Polyadic pi-Calculus Approach for the Formal Specification of UML-RT

We present a regression test selection technique for C# programs. C# is fairly new and is often used within the Microsoft .Net framework to give programmers a solid base to develop a variety of applications. Regression testing is done after modifying a program. Regression test selection refers to selecting a suitable subset of test cases from the original test suite in order to be rerun. It aims to provide confidence that the modifications are correct and did not affect other unmodified parts of the program. The regression test selection technique presented in this paper accounts for C#.Net specific features. Our technique is based on three phases; the first phase builds an Affected Class Diagram consisting of classes that are affected by the change in the source code. The second phase builds a C# Interclass Graph (CIG) from the affected class diagram based on C# specific features. In this phase, we reduce the number of selected test cases. The third phase involves further reduction and a new metric for assigning weights to test cases for prioritizing the selected test cases. We have empirically validated the proposed technique by using case studies. The empirical results show the usefulness of the proposed regression testing technique for C#.Net programs.

Nashat Mansour

Wael Statieh

Regression Test Selection for C# Programs

Distributed Software Development (DSD) has recently evolved, resulting in an increase in the available literature. Organizations now have a tendency to make greater development efforts in more attractive zones. The main advantage of this lies in a greater availability of human resources in decentralized zones at less cost. There are, however, some disadvantages which are caused by the distance that separates the development teams. Coordination and communication become more difficult as the software components are sourced from different places, thus affecting project organization, project control, and product quality. New processes and tools are consequently necessary. This work presents the findings of a systematic review of the literature related to the challenges concerning Distributed Software Development, whose purpose is to identify the solutions and improvements proposed up to the present day.

Miguel Jim&#233;nez

Mario Piattini

Aurora Vizca&#237;no

Challenges and Improvements in Distributed Software Development: A Systematic Review

This paper presents high-level functional Web components such as frames, framesets, and pivot tables, which conventional development environments for Web applications have not yet supported. Frameset Web components provide several editing facilities such as adding, deleting, changing, and nesting of framesets to make it easier to develop Web applications that use frame facilities. Pivot table Web components sum up various kinds of data in two dimensions. They reduce the amount of code to be written by developers greatly. The paper also describes the system that implements these high-level functional components as visual Web components. This system assists designers in the development of Web applications based on the page-transition framework that models a Web application as a set of Web page transitions, and by using visual Web components, makes it easier to write processes to be executed when a Web page transfers to another.

Quan Liang Chen

Takao Shimomura

Automatic Generation of Web Applications from Visual High-Level Functional Web Components

About this journal

Journal profile

Meet the editorial board

Editor spotlight

Submit your proposal

Do you think there is an emerging area of research that really needs to be highlighted? Or an existing research area that has been overlooked or would benefit from deeper investigation? Raise the profile of a research area by leading a Special Issue.

Advances in Software Engineering