In recent years, Web applications have grown rapidly because of their abilities to provide online information access to anyone at anytime around the world. As Web applications become complex, there is a growing concern about their quality and reliability. This paper extends traditional data flow testing techniques to Web applications. Several data flow issues about analyzing HyperText Markup Language (HTML) documents in Web applications are discussed. An object-based data flow testing approach is presented. The approach is based on a test model that captures data flow test artifacts of Web applications. In the test model, each entity of a Web application is modeled as an object. The data flow information of the functions within an object or across objects is then captured using various flow graphs. Based on the object-based test model, data flow test cases for a Web application can be systematically and selectively generated in five different levels.

Recently the number of Web applications has increased immensely. Many businesses have been using Web applications for their mission-critical operations. As Web applications become complex, their quality and reliability become crucial. The paper describes an object oriented test model that captures both structural and behavioral test artifacts of Web applications. The model represents the entities of Web applications as objects and describes their structures, relationships, and dynamic behaviors. Based on the test model, test methods are presented to derive test cases automatically for ensuring the structures and behaviors of Web applications.

In recent years, Web applications have become prevalent around the world. Many companies have developed or integrated their mission-critical applications using Web technologies. As Web applications become more complex, testing Web applications becomes crucial. We extend data flow testing techniques to Web applications. Several data flow issues for analyzing HTML and eXtensible Markup Language (XML) documents in Web applications are discussed. An approach to supporting data flow testing for Web applications is presented. In our approach, the structural test artifacts of a Web application are captured in a Web Application Test Model (WATM) where each component of the Web application is treated as an object. The elements of an HTML or XML document are considered as structured variables within an object. Data flow test cases for Web applications are derived from flow graphs in five levels according to the types of definition-use chains for the variables of interest.

Object Behavior Logic (OBL) is proposed in order to specify object oriented system behavior. An inference engine is introduced for verifying the consistency of the systems based on the specification in OBL. OBL uses the paradigms of state machine to catch the dynamic aspect of object oriented systems in formal specification, plus the features of object oriented concepts such as inheritance, instantiation, and so forth, which separate the unique object oriented techniques from the function oriented techniques.

Brooks' law says that adding manpower to a late software project makes it later. F.P. Brooks Jr. (1995) developed the law through observation of many projects and derived the generalization. His explanation was quite reasonable and convincing. However, it becomes a debilitating statement to any software project manager who is faced with a late project. This paper presents an in-depth study of Brooks' law using the system dynamics simulation approach. Unlike the first-order approximation of Brooks' law, we found some interesting results that can benefit practicing project managers. We found that adding people to a late project will always increase its cost, but the project may not always be late. Only under a certain degree of sequential constraints among the project tasks will the project be delayed. To investigate the impact of sequential constraints, we simulated numerous task conditions and found that there is a time-line T for each project which means that, if enough manpower is added before T, the project still can finish before the scheduled deadline. If the manpower adjustment is after T, then the project will definitely be late. In this way, Brooks' law is revised and turned into a useful guiding principle to benefit software development.

In this paper, we present a dynamic state testing approach for a reusable CORBA component by constructing perception-based state machines and a state-based replay system in the CORBA environment. The state machines are constructed based on the perceptions of the remote component used in our application. Based on the state machine, we also design a program replay system to make the testing deterministic since CORBA components have nondeterministic execution behavior which makes testing inefficient ineffective and not reproducible. With our testing approach, testers can detect state behavioral errors of an uncertain reusable component dynamically and deterministically in the CORBA environment.

Incremental delivery (ID) is a software development paradigm which advocates that systems be delivered to end users in usable, useful and semi-independent increments. ID differs from the traditional development paradigm, which we call monolithic delivery (MD), in which a software system is considered as a monolithic, inseparable whole delivered as one unit. The purpose of this study is to compare the ID and MD approaches in terms of their maintenance efforts through an analytical parametric study. The results of the study provide insight into how incremental delivery can be employed to reduce software maintenance effort. © 1998 John Wiley & Sons, Ltd.

No abstract available.

The object-orientated paradigm provides the power for software development but at the same time introduces some brand new problems. One of these problems is that the relationships among classes are more complex and difficult to identify than those in the traditional paradigm. This problem becomes a major obstacle for regression testing of OO software, in which the relationships among classes as well as those between test cases and classes, must be determined a priori. In this paper we propose a new method to select only a fraction of the test cases from the entire test suite to revalidate an OO software system. This method is based on the concepts of class firewall and of marking all the classes ‘touched’ by a test case. From the class firewall, we can identify all of the affected classes after a new version of software is released. Together with the markings, we can also identify all the test cases in the test suite that need to be retested after the software change. A step-by-step process is proposed to identify the relationships between classes and test cases, compute the class firewall, and select only the appropriate test cases for retesting. © 1997 John Wiley & Sons, Ltd.

This paper presents a history-based approach to detect class faults that a test set may fail to uncover. The method sequence test history contains the run-time information about object states, state transitions, and dependence relations between data members. The approach examines the test history to determine if some faulty state (or new state) is reachable from the states that have been covered by the test set. The main benefit of the approach is that it only depends on the existing test set that has been executed, and hence it does not require the development of any new test case.

Object state behavior implies that the effect of an operation on an object may depend on the states of the object and other objects. It may cause state changes to more than one object. Thus, the combined or composite effects of the object operations must be analyzed and tested. We show that certain object state behavior errors cannot be detected readily by conventional testing methods. We describe an object state test method consisting of an object state model, a reverse engineering tool, and a composite object state testing tool. The object state test model is an aggregation of hierarchical, concurrent, communicating state machines envisioned mainly for object state testing. The reverse engineering tool produces an object state model from any C++ program. The composite object state testing tool analyzes the object state behaviors and generates test cases for testing object state interactions. We show the detection of several composite object state behavior errors that exist in a well-known thermostat example.

Since polymorphism in object-orientated (OO) programming is an important feature and tool to increase the reusability and extensibility of object-orientated programs, understanding and identifying polymorphism changes and their impacts in an object-orientated program is very important in software maintenance. Although many published research articles have addressed the polymorphism feature in object-orientated programs, almost none of them have discussed software maintenance issues on identification of polymorphism change and impact. This paper proposes a formal software maintenance model for polymorphism in object-orientated programs, and discusses a systematic approach to track different polymorphism changes and their ripple effects. In addition, it reports on the implementation of a relevant tool, OOTME, and its use on two case studies.

Since class objects are the major components in object oriented (OO) programs during run time, testing the behavior of these objects become an important task in testing of object oriented programs to complement other types of testing, such as, structure testing and functional testing. To check the behavior of objects in OO programs, it is essential to check each state and each transition for every object. The paper proposes a new test model, called object state diagram, to capture and represent the dynamic behavior of objects in an OO program. The model is an extension of the existing state models, it supports basic OO features, such as class objects, inheritance, aggregation and overloading. Unlike other models, it is a concurrent, communicating state machine which has the capability of representing the object state hierarchy for a complex class object. Based on this model we address the issues and solutions to object state test strategy, test criteria and test generation.

The complexity and interdependencies of an object oriented program makes testing of such programs difficult. We present a reverse engineering based model called Object Relation Diagram (ORD), which is generated from analyzing the C++ source code of an object oriented program. An ORD is a directed graph in which the vertices represent the object classes and the edges represent the relationships among the object classes. Based on the ORD, a test strategy, called test order, for unit testing and integration testing of object oriented programs is described. The test order algorithm uses topological sorting and clusters of strongly connected subgraphs of the ORD. It computes the optimal test order in the sense that the effort required to construct the test stubs to simulate the untested classes/member functions is minimum. We show the savings of the test strategy through statistics of the InterViews library.

Software development techniques have seen significant progress since the 1960s. Most research accomplishments have been in software development but not in software maintenance. This is also true for the object-oriented paradigm. We believe that the features of object-oriented approach have a significant impact on maintainability. We report an incipient study indicating that the architecture of an object-oriented system indeed affects its maintainability. This is attributed to the structure of its inheritance hierarchy, among other factors. We also attempt to provide some rationale behind this phenomenon. The possible tension between object reuse and the maintainability of its product is also discussed in the paper.

Acceptance testing is the determining factor in the satisfaction of the contract between the software vendor and the customer. In today's industry practice, there is a lack of a systematic method to help testers (or customers) construct, formalize, and verify acceptance testing models, and use them for automatic test case generation. This paper proposes a systematic approach to form the acceptance test model for a software system to represent its external behavior from the users' perspectives. Based on the generated test model, different rigorous acceptance test criteria are defined, and various types of acceptance testing are discussed.>

The importance of object state testing is illustrated through a simple example. We show that certain errors in the implementation of object state behavior cannot be readily detected by conventional structural testing, functional testing, and state testing. We describe an object state test model and outline a reverse engineering method for extracting object state behaviors from C++ source code. The object state test model is a hierarchical, concurrent, communicating state machine. It resembles the concepts of inheritance and aggregation in the object-oriented paradigm rather than the concept of state decomposition as in some existing models. The reverse engineering method is based on symbolic execution to extract the states and effects of the member functions. The symbolic execution results are used to construct the state machines. The usefulness of the model and of the method is discussed in the context of object state testing in the detection of a state behavior error. >

Object-oriented conceptual modeling captures real world entities as close as possible. Data and functions on encapsulated in an object. This allows software to be easily adapted to changes in the application. We present an object-oriented approach for modeling and analysis of time dependent systems. It describes the structural aspect and the time critical behavioral aspect of objects in one model and from which formal analysis can be conducted to verify desirable properties. In particular, the main concern of behavioral modeling is to present the specification of temporal knowledge about object activities such as their chronological ordering, durations, and time limits.>

In the object-oriented (OO) paradigm, new features (such as encapsulation, aggregation, inheritance, polymorphism and dynamic binding) introduce new problems in software testing and maintenance. One of them is the difficulty of identifying the affected components (such as classes) when changes are made in object-oriented class libraries or programs. This paper discusses the types of code changes in an object-oriented class library, and provides an automated solution to identify different kinds of code changes and their impact. In addition, an OO software maintenance environment that implements the research result is described. Our experience with the environment prototype shows promising results.>

An incremental delivery approach to system development is proposed and established. It permits usable and useful subsystems to be delivered before the entire project is completed. Two case studies were conducted to evaluate the effectiveness of the approach and to determine its applicability. An overall discussion is given, and it is concluded that the approach is a feasible and promising technique.>

Requirements clustering provides a new approach to system decomposition. It makes it possible to subdivide a large system into user-recognizable components where each component can be used, almost independently, to satisfy part of the user's needs. The underlying concept of requirements clustering is presented. A requirements-clustering algorithm, which is based on the concept of scenario-based prototyping and the notion of covering in graph theory, is described. Its implications to software incremental delivery are discussed. A case study conducted to demonstrate the application of requirements clustering to facilitate software development is described.>

A study is made of the impact of requirements changes on systems of equivalent functionality but with a different underlying development paradigm. An incremental delivery paradigm is compared to the traditional top-down complete development paradigm. The study seeks to determine the existence and possible nature of any significant differences in cost between the incremental delivery paradigm and the traditional development paradigm. To do so, the general form of an experimental process including six trials that involved single programmers is outlined. The programmers made modifications, based on new specifications, to two equivalent systems, each constructed according to one of the two paradigms, until the altered programs once again functioned as expected. The size of the changes and effort expended was recorded and tabulated to reflect the 'cost' of maintenance updates in both paradigms. The results of the study are analyzed, and the outcomes can be used to explore future research directions for incremental delivery methodologies.>

Programmers, even in well-organized software environments which utilize some modern software engineering practices, are often lacking of a discipline in their individual programming effort. There has not been an emphasis on discipline in progamming practice, as is traditional in other engineering and scientific fields' instruction. A framework organized to be suitable for early presentation and developing usage is presented and evaluated. It integrates the notions of top-down design, stepwise refinement, structured flowcharting, test case description, and analysis in the context of a framework for systematically developing and concurrently documenting programs. The framework was evaluated in actual usage during introductory programming instruction by comparing it to a typical conventional approach. A comparison of programming effort showed only a 16 percent increase in time required in the disciplined approach, which certainly makes it feasible for introductory instruction. Program quality comparisons were carried out by a comprehensive testing for logic errors in the completed projects. The results were impressively favorable for the disciplined approach.

This paper describes an approach that can introduce some of the concepts of software engineering to general business, engineering, and science students in an introductory FORTRAN programming course. The approach integrates the notions of top-down design, stepwise refinement, structured flowcharting, test case description, and analysis in the context of a methodology for systematically developing and documenting programs. Qualitative results from teaching these concepts are presented.