Data flow-oriented coverage criteria are widely used in software testing. This paper proposes three novel def-use coverage criteria. The main objective of these criteria is to improve the specificity of test goals, to obtain more easily understood test cases, and to strengthen fault detection of derived test suites.

The purpose of the method is to increase the sensitivity of an automatically generated test suite to mutations of a model. Unlike existing methods for generating test scenarios that use the mutational approach to assess the resulting test set, the proposed method analyzes the possibility of detecting mutations on the fly, in the process of analyzing the model’s behavior space, by adding of special coverage goals. Two types of mutants manifestation are considered: deviations in the behavior of paths for (weak case) and in the observed output (strong case). A new algorithm is proposed for efficient search of a path with observable effect of a mutation.

Testing of modernized legacy systems is difficult due to that typically requirements specifications do not exist and that detailed knowledge of the architecture and design of the system may have been lost. In this paper we present an approach which derives test suites for a modernized legacy systems from the legacy code. We extend our earlier presented approach deriving test suites from use case map (UCM) specifications of a system by transforming the legacy code into a UCM model. We further discuss enhancements to the test generation process required to operate on the large models obtained from realistic legacy systems and to assure that the generated tests are meaningful to the tester. This approach has been used to validate the modernization of large (in excess of 20 million lines of code) mainframe applications implemented in COBOL.

This paper focuses on challenges to automatic test suite generation from formal models of software systems. Popular tools and methods and their limitations are discussed. Data cohesion, meaningfulness of derived behavior, usefulness for debugging, coverage evenness, coverage overlap, fault detection ability, and size of the generated test suite are considered as quality indicators for generated tests. A novel composite weight-based heuristic method for improving the quality of automatically generated test scenarios is proposed.

Insertion modeling has been developed over the last decade as an approach to a general theory of interaction between agents and an environment in complex distributed multiagent systems. The original work in this direction proposed a model of interaction between agents and environments based on an insertion function and the algebra of behaviors (similar to process algebra). Over the recent years, insertion modeling has been applied to the verification of requirement specifications of distributed interacting systems and to the generation of tests from such requirements. Our system, VRS (Verification of Requirements Specifications), has successfully verified specifications in the field of telecommunication systems, embedded systems, and real-time systems. Formal requirements in VRS are presented by means of local descriptions with a succession relation. Formalized requirements are represented in a formalism that combines logical specifications with control descriptions provided by the graphical syntax of UCM (Use Case Map) diagrams. This paper overviews the main concepts of insertion modeling, presents new algorithms developed for symbolic verification, especially a new predicate transformer for local descriptions, and provides a formal description of the method of generating traces from such specifications (which is the key technology used to verify requirements and derive test suites).

Object oriented programming languages raised the level of abstraction by incorporating first class query constructs explicitly into program codes. These query constructs allow programmers to express operations over collections as object queries. They also provide optimal query execution, utilizing query optimization strategies from the database domain. However, when a query is repeated in the program, it is executed as a new query. Existing approaches, however, such as Java Query Language (JQL), which caches such query constructs on collections have high run time overhead. Therefore, this paper presents an approach to reduce the run time execution of programs involving explicit queries by caching the results of repeated queries while incrementally maintaining the cached results. We performed the pattern matching of both queries and updates at compile time. We propose several cache heuristics that determine not only which queries to cache but also when to stop the incremental maintenance of cached query results. We also propose a method for the incremental maintenance of cached results of queries by handling different types of update operations such as addition, removal of objects from the collections and field value modifications of the object states. We incorporated cache replacement policies that replace the queries from the cache when the cache size is full. Our experimental results demonstrate that our approaches of caching and incrementalization have reduced execution times for the programs with object queries on collections when compared with earlier approaches such as JQL.

VRS (Verification Requirements Specifications) system is a tool for processing formal requirements during the initial stage of software, hardware, or system development. Symbolic modeling and deductive methods are used for detection of issues such as safety violations, deadlocks, nondeterminism, or livelocks. The formal representation of requirements also supports the generation of test suites as well as the synthesis of a design model.

Object oriented programming languages raised the level of abstraction by supporting the explicit first class query constructs in the programming codes. The query constructs can be optimized by leveraging the techniques of query optimization from the domain of databases. The existing optimization approaches such as JQL, however, incur high run time overhead as optimizations are performed only at run time. Therefore, in this paper, we propose an approach that performs the query optimization at compile time utilizing the metadata annotations in the source code. The proposed approach first collects the data from the sample execution of the program and extracts the essential metadata for the string valued attributes. Then, the annotations consisting of the metadata values associated with string attributes are generated in the source code and the histograms are built using those annotations. The selectivity estimates of the predicates and the joins in the query are computed from the histograms. Next, the query plan is generated at compile time through the maximum selectivity heuristic. The query plan is modified at run time in cases of significant updates to the string data. The approach also incorporates the cache heuristics that determine whether to cache the query result or not. The cached query results are incrementally maintained up-to-date. Our experimental results demonstrate that our approach has reduced the run time of the program more than the earlier approaches such as JQL.

Many large programs operate on collection types. Extensive libraries are available in many programming languages, such as the C++ Standard Template Library, which make programming with collections convenient. Extending programming languages to provide collection queries as first class constructs in the language would not only allow programmers to write queries explicitly in their programs but it would also allow compilers to leverage the wealth of experience available from the database domain to optimize such queries. This paper describes an approach to reduce the run time of programs involving explicit collection queries by performing run time query optimization that is effective for single runs of a program. In addition, it also leverages a cache to store previously computed results. The proposed approach relies on histograms built from the data at run time to estimate the selectivity of joins and predicates in order to construct query plans. Information from earlier executions of the same query during run time is leveraged during the construction of the query plans, even when the data has changed between these executions. An effective cache policy is also determined for caching the results of join (sub) queries. The cache is maintained incrementally, when the underlying collections change, and use of the cache space is optimized by a cache replacement policy. Our approach has been implemented within the Java Query Language (JQL) framework using AspectJ. Our approach demonstrated that its run time query optimization in integration with caching sub query result significantly improves the run time of programs with explicit queries over equivalent programs performing collection operations by iterating over those collections. This paper evaluates our approach using synthetic as well as real world Robocode programs by comparing it to JQL as a benchmark. Experimental results show that our approach performs better than the JQL approach with respect to the program run time.

Object oriented programming languages have raised the level of abstraction by supporting the object querying on collections. Programming languages can execute first class query constructs, using query optimization techniques from the database field, for run time optimizations. Existing approaches, however, such as Java Query Language (JQL), which executes such query constructs on collections have high run time overhead. Therefore, we propose an approach to reduce the burden of run time overhead by performing most of the query optimization for object queries on collections at compile time. This approach both analyzes the source code and obtains the metadata provided through annotations. It relies on building histograms from the metadata information. Then, the predicate and join selectivity estimates within a query are computed from these histograms. The selectivity estimates are maintained accurate with the incremental maintenance of histograms to the data changes in the program at run time. Next, both the selection and join optimizations are applied on the queries. The optimizations help in skipping and eliminating the execution of some of the predicates and joins based on the collected metadata. Finally, a query plan is generated at the compile time through the proposed selectivity cost heuristic. The query itself is executed at run time according to the determined query plan. But, in cases of inaccurate metadata and significant data changes in the source code, the query plan is modified at run time according to the correct selectivity estimates obtained from the updated histograms. Our experimental results demonstrate that our approach reduces the run time overhead of a program with collections more than the earlier approaches such as JQL.

Region composition is an operation where transitions of different automaton are woven together according to synchronization constraints. Reasoning about properties across regions is difficult, which is problematic in systems that are assembled by composing a large number of regions. We introduce two transactions constructs to enforce causality properties between transitions of a state machine. We show that transactions can be checked statically and that they support modular reasoning about region composition by preserving liveness properties within the scope of a transaction.

Object oriented programming languages raised the level of abstraction by incorporating first class query constructs explicitly in the program codes. These query constructs allow programmers to express operations over collections as object queries and also provide optimal query execution utilizing query optimization strategies from domain of databases. However, when a query is repeated in the program, it is executed afresh. This paper presents an approach to reduce the run time execution of programs involving explicit queries by caching the results of repeated queries and incrementally maintaining the cached results. We propose determination of cache entries at compile time by performing the program analysis. We also describe the cache heuristics for determining which queries to cache.

We present a framework to assemble concurrent applications from modules that capture reusable architectural pat-terns. The framework focuses on concurrent systems where computational processes communicate through asynchronous messages. The language provides support to modularize architectural patterns at different levels of granularity, using agents, regions, aspects and morphing. We present sample implementations of the architectural patterns and show how they are composed using a real-world example. Finally discuss how the deployment and composition of patterns can be further automated.

The fourth ACES-MB workshop brought together researchers and practitioners interested in model-based software engineering for real-time embedded systems, with a particular focus on the use of models for architecture description and domain-specific design, and for capturing non-functional constraints. Six presenters proposed contributions on a systematic transition from systems modeling using SysML to software modeling using UML, verification of initial architecture models against requirements using consistency checking techniques, techniques to check the validity of refinement relation between abstraction levels, constructing rapid prototypes to assess the behavioral design characteristics, new abstraction layers to describe operating system and mixed-signal issues, and a model-driven approach for parallelizing software programs. In addition, a lively group discussion tackled these issues in further detail. This report presents an overview of the presentations and fruitful discussions that took place during the ACES-MB 2011 workshop.

This paper presents a modeling language to modularize the features of a system using orthogonal regions and to man-age the interactions between these features. Orthogonal regions are a language construct to structure a state ma-chine into a set of semi-independent behaviors. We intro-duce two concepts to manage the interactions between regions. First, we present a notion of interface between re-gions which captures the essence of their interactions. Second, we introduce a transactional composition operator to synchronize the regions and check the interaction for non-determinism and termination. The approach is eva-luated by comparing a monolithic legacy implementation of a telecommunication component to two refactored implementations. Our results show that transactional region composition can achieves independence between the im-plementations of the features of the system and that it improves the cohesion of the regions, compared to classic regions.

A key question for system testing of a software product is how to determine that the semantics of its requirements is adequately realized in the given implementation, or alternatively to find a series of concrete counter-examples demonstrating the violation of (a) particular requirement(s). An adequate test suite will aid in this determination. This paper formulates three types of requirements coverage criteria to establish the adequacy of a test suite. The suggested approach to system testing was validated in a number of medium and large size industrial projects.