Abstract: This paper is aimed at creating an Automatic Java X-Machine testing tool for software development. The nature of software development is changing; thus, the type of software testing tools required is also changing. Software is growing increasingly complex and, in part due to commercial impetus for faster software releases with new features and value, increasingly in danger of containing faults. These faults can incur huge cost for software development organisations and users; Cambridge Judge Business School’s research estimated the cost of software bugs to the global economy is $312 billion. Beyond the cost, faster software development methodologies and increasing expectations on developers to become testers is driving demand for faster, automated, and effective tools to prevent potential faults as early as possible in the software development lifecycle. Using X-Machine theory, this paper will explore a new tool to address software complexity, changing expectations on developers, faster development pressures and methodologies, with a view to reducing the huge cost of fixing software bugs.
Abstract: Growing dependency of mankind on software
technology increases the need for thorough testing of the software
applications and automated testing techniques that support testing
activities. We have outlined our testing strategy for performing
various types of automated testing of Java applications using
AspectJ which has become the de-facto standard for Aspect Oriented
Programming (AOP). Likewise JUnit, a unit testing framework is
the most popular Java testing tool. In this paper, we have evaluated
our proposed AOP approach for automated testing and JUnit on
various parameters. First we have provided the similarity between
the two approaches and then we have done a detailed comparison
of the two testing techniques on factors like lines of testing code,
learning curve, testing of private members etc. We established that
our AOP testing approach using AspectJ has got several advantages
and is thus particularly more effective than JUnit.
Abstract: Manual writing of test cases from functional requirements is a time-consuming task. Such test cases are not only difficult to write but are also challenging to maintain. Test cases can be drawn from the functional requirements that are expressed in natural language. However, manual test case generation is inefficient and subject to errors. In this paper, we have presented a systematic procedure that could automatically derive test cases from user stories. The user stories are specified in a restricted natural language using a well-defined template. We have also presented a detailed methodology for writing our test ready user stories. Our tool “Test-o-Matic” automatically generates the test cases by processing the restricted user stories. The generated test cases are executed by using open source Selenium IDE. We evaluate our approach on a case study, which is an open source web based application. Effectiveness of our approach is evaluated by seeding faults in the open source case study using known mutation operators. Results show that the test case generation from restricted user stories is a viable approach for automated testing of web applications.
Abstract: Test automation allows performing difficult and time
consuming manual software testing tasks efficiently, quickly and
repeatedly. However, development and maintenance of automated
tests is expensive, so it needs a proper prioritization what to automate
first. This paper describes a simple yet efficient approach for such
prioritization of test cases based on the effort needed for both manual
execution and software test automation. The suggested approach is
very flexible because it allows working with a variety of assessment
methods, and adding or removing new candidates at any time. The
theoretical ideas presented in this article have been successfully
applied in real world situations in several software companies by the
authors and their colleagues including testing of real estate websites,
cryptographic and authentication solutions, OSGi-based middleware
framework that has been applied in various systems for smart homes,
connected cars, production plants, sensors, home appliances, car head
units and engine control units (ECU), vending machines, medical
devices, industry equipment and other devices that either contain or
are connected to an embedded service gateway.
Abstract: Autonomous mobile robots can be found in a wide
field of applications. Their types range from household robots over
workshop robots to autonomous cars and many more. All of them
undergo a number of testing steps during development, production
and maintenance. This paper describes an approach to improve
testing of robot behavior. It was inspired by the RoboCup @work
competition that itself reflects a robotics benchmark for industrial
robotics. There, scaled down versions of mobile industrial robots
have to navigate through a workshop-like environment or operation
area and have to perform tasks of manipulating and transporting
work pieces. This paper will introduce an approach of automated
vision-based testing of the behavior of the so called youBot robot,
which is the most widely used robot platform in the RoboCup
@work competition. The proposed system allows automated testing
of multiple tries of the robot to perform a specific missions and
it allows for the flexibility of the robot, e.g. selecting different
paths between two tasks within a mission. The approach is based
on a multi-camera setup using, off the shelf cameras and optical
markers. It has been applied for test-driven development (TDD) and
maintenance-like verification of the robot behavior and performance.
Abstract: The evolution of current modeling specifications gives rise to the problem of generating automated test cases from a variety of application tools. Past endeavours on behavioural testing of UML statecharts have not systematically leveraged the potential of existing graph theory for testing of objects. Therefore there exists a need for a simple, tool-independent, and effective method for automatic test generation. An architecture, codenamed ACUTE-J (Automated stateChart Unit Testing Engine for Java), for automating the unit test generation process is presented. A sequential approach for converting UML statechart diagrams to JUnit test classes is described, with the application of existing graph theory. Research byproducts such as a universal XML Schema and API for statechart-driven testing are also proposed. The result from a Java implementation of ACUTE-J is discussed in brief. The Chinese Postman algorithm is utilised as an illustration for a run-through of the ACUTE-J architecture.
Abstract: System testing is actually done to the entire system
against the Functional Requirement Specification and/or the System
Requirement Specification. Moreover, it is an investigatory testing
phase, where the focus is to have almost a destructive attitude and
test not only the design, but also the behavior and even the believed
expectations of the customer. It is also intended to test up to and
beyond the bounds defined in the software/hardware requirements
specifications. In Motorola®, Automated Testing is one of the testing
methodologies uses by GSG-iSGT (Global Software Group - iDEN
TM
Subcriber Group-Test) to increase the testing volume, productivity
and reduce test cycle-time in iDEN
TM
phones testing. Testing is able
to produce more robust products before release to the market. In this
paper, iHopper is proposed as a tool to perform stress test on iDEN
TM
phonse. We will discuss the value that automation has brought to
iDEN
TM
Phone testing such as improving software quality in the
iDEN
TM
phone together with some metrics. We will also look into
the advantages of the proposed system and some discussion of the
future work as well.
Abstract: An application framework provides a reusable design
and implementation for a family of software systems. Frameworks
are introduced to reduce the cost of a product line (i.e., a family of
products that shares the common features). Software testing is a timeconsuming
and costly ongoing activity during the application
software development process. Generating reusable test cases for the
framework applications during the framework development stage,
and providing and using the test cases to test part of the framework
application whenever the framework is used reduces the application
development time and cost considerably. This paper introduces the
Framework Interface State Transition Tester (FIST2), a tool for
automated unit testing of Java framework applications. During the
framework development stage, given the formal descriptions of the
framework hooks, the specifications of the methods of the
framework-s extensible classes, and the illegal behavior description
of the Framework Interface Classes (FICs), FIST2 generates unitlevel
test cases for the classes. At the framework application
development stage, given the customized method specifications of
the implemented FICs, FIST2 automates the use, execution, and
evaluation of the already generated test cases to test the implemented
FICs. The paper illustrates the use of the FIST2 tool for testing
several applications that use the SalesPoint framework.