Abstract: An application framework provides a reusable design
and implementation for a family of software systems. Application
developers extend the framework to build their particular
applications using hooks. Hooks are the places identified to show
how to use and customize the framework. Hooks define Framework
Interface Classes (FICs) and their possible specifications, which
helps in building reusable test cases for the implementations of these
classes. In applications developed using gray-box frameworks, FICs
inherit framework classes or use them without inheritance. In this
paper, a test-case generation technique is extended to build test cases
for FICs built for gray-box frameworks. A tool is developed to
automate the introduced technique.
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., family of products that share the common features). Software
testing is a time consuming and costly ongoing activity during the
application software development process. Generating reusable test
cases for the framework applications at 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.
Framework Interface Classes (FICs) are classes introduced by
the framework hooks to be implemented at the application
development stage. They can have reusable test cases generated at
the framework development stage and provided with the
framework to test the implementations of the FICs at the
application development stage. In this paper, we conduct a case
study using thirteen applications developed using three
frameworks; one domain oriented and two application oriented.
The results show that, in general, the percentage of the number of
FICs in the applications developed using domain frameworks is, on
average, greater than the percentage of the number of FICs in the
applications developed using application frameworks.
Consequently, the reduction of the application unit testing time
using the reusable test cases generated for domain frameworks is,
in general, greater than the reduction of the application unit testing
time using the reusable test cases generated for application
frameworks.
Abstract: An application framework provides a reusable design
and implementation for a family of software systems. Application
developers extend the framework to build their particular
applications using hooks. Hooks are the places identified to show
how to use and customize the framework. Hooks define the
Framework Interface Classes (FICs) and the specifications of their
methods. As part of the development life cycle, it is required to test
the implementations of the FICs. Building a testing model to express
the behavior of a class is an essential step for the generation of the
class-based test cases. The testing model has to be consistent with the
specifications provided for the hooks. State-based models consisting
of states and transitions are testing models well suited to objectoriented
software. Typically, hand-construction of a state-based
model of a class behavior is expensive, error-prone, and may result in
constructing an inconsistent model with the specifications of the class
methods, which misleads verification results. In this paper, a
technique is introduced to automatically synthesize a state-based
testing model for FICs using the specifications provided for the
hooks. A tool that supports the proposed technique is introduced.
Abstract: An application framework provides a reusable design
and implementation for a family of software systems. Application
developers extend the framework to build their particular
applications using hooks. Hooks are the places identified to show
how to use and customize the framework. Hooks define the
Framework Interface Classes (FICs) and their possible specifications,
which helps in building reusable test cases for the implementations of
these classes. This paper introduces a novel technique called all
paths-state to generate state-based test cases to test the FICs at class
level. The technique is experimentally evaluated. The empirical
evaluation shows that all paths-state technique produces test cases
with a high degree of coverage for the specifications of the
implemented FICs comparing to test cases generated using round-trip
path and all-transition techniques.
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.
Abstract: An application framework provides a reusable design
and implementation for a family of software systems. If the
framework contains defects, the defects will be passed on to the
applications developed from the framework. Framework defects are
hard to discover at the time the framework is instantiated. Therefore,
it is important to remove all defects before instantiating the
framework. In this paper, two measures for the adequacy of an
object-oriented system-based testing technique are introduced. The
measures assess the usefulness and uniqueness of the testing
technique. The two measures are applied to experimentally compare
the adequacy of two testing techniques introduced to test objectoriented
frameworks at the system level. The two considered testing
techniques are the New Framework Test Approach and Testing
Frameworks Through Hooks (TFTH). The techniques are also
compared analytically in terms of their coverage power of objectoriented
aspects. The comparison study results show that the TFTH
technique is better than the New Framework Test Approach in terms
of usefulness degree, uniqueness degree, and coverage power.