Pham Ngoc Hung

Modular Conformance Testing and Assume-Guarantee Verification for Evolving Component-Based Software

This paper proposes a framework for verifying component-based software in the context of component evolution. This framework includes two stages: modular conformance testing for updating inaccurate model of the evolved component and modular verification for evolving component-based software. When a component is evolved after adapting some refinements, the proposed framework only focuses on this component and its model in order to update the model and recheck the whole evolved system. The framework also reuses the previous verification results and the previous models of the evolved component to reduce several steps of the model update and verification processes.

An assume-guarantee model checker for component-based systems

This paper introduces an assume-guarantee model checker, named AGMC, for verifying correctness of designs of component-based systems. Given UML 2.0 sequence diagrams that describe behaviors of the system components and a required property, AGMC generates accurate models of the components represented by labeled transition systems (LTSs) automatically. AGMC then model checks that whether the system satisfies the property by using the assume-guarantee verification method. AGMC has been implemented and tested by applying some typical component-based systems. The implemented AGMC is not only useful to verify component-based systems in practice but also has a potential to solve the state space explosion problem in model checking.

A Minimized Assumption Generation Method for Component-Based Software Verification

An assume-guarantee verification method has been recognized as a promising approach to verify component-based software with model checking. The method is not only fitted to component-based software but also has a potential to solve the state space explosion problem in model checking. This method allows us to decompose a verification target into components so that we can model check each of them separately. In this method, assumptions which are environments of the components are generated. The number of states of the assumptions should be minimized because the computational cost of model checking is influenced by that number. Thus, we propose a method for generating minimal assumptions for the assume-guarantee verification of component-based software. The key idea of this method is finding the minimal assumptions in the search spaces of the candidate assumptions. These assumptions are seen as the environments needed for the components to satisfy a property and for the rest of the system to be satisfied. The minimal assumptions generated by the proposed method can be used to recheck the whole system at much lower computational cost. We have implemented a tool for generating the minimal assumptions. Experimental results are also presented and discussed.

Assume-Guarantee Tools for Component-Based Software Verification

This paper presents a minimized assumption generation method and its associated tools for L*-based assume-guarantee verification of component-based software by model checking. The method is not only fitted to component-based software but also has a potential to solve the state space explosion problem in model checking. In the proposed method, a verification target is decomposed into components so that we can model check each of them separately. The key idea of this method is finding the minimal assumptions in the search spaces of the candidate assumptions. The minimal assumptions generated by the proposed method can be used to recheck the whole system at much lower computational cost. Our experience so far indicates that the implemented tools are potential for verifying practical component-based software.

A Method for Automated Test Data Generation from Sequence Diagrams and Object Constraint Language

This paper proposes an automated test data generation method from the information embedded in model elements such as Unified Modeling Language (UML) sequence diagrams, class diagrams, and Object Constraint Language (OCL). The method supports UML 2.0 sequence diagrams including eight kinds of combined fragments describing control flow of systems. Comparing with some approaches by using depth first search (DFS) or breadth first search (BFS) algorithms, the proposed method generates all possible test scenarios with the higher error uncover capability. Test data for testing loop fragment is also generated. Therefore, it helps to detect errors in testing loops and the concurrency errors such as safety and liveness property of the systems.

A Method for Generating Models of Black-Box Components

The model-based approaches are difficult to be applied in practice due to the lack of formal models describing behaviors of systems. This paper proposes a method for generating accurate models of components in order to solve this issue in the context of the component-based systems. The key idea of this method is to generate minimal deterministic finite automata as the accurate models of the corresponding components. For this purpose, the proposed method first computes a set of traces as a regular language of a given component by executing all possible experiments over the alphabet of the component. This method then constructs a regular expression to represent this set. After that, a minimal deterministic finite automaton as an accurate model of the component is generated by applying the Thompson algorithm and some optimized activities. The generated models are useful for the existing model-based approaches, e.g., model checking and model-based testing in improving quality of component-based software. An implemented tool supporting the method and experimental results are also presented.

A method for automated unit testing of C programs

This research proposes an automated test case generation method for C functions. In this method, the source code is transformed into a control flow graph corresponding to the given coverage criterion. After that, a list of feasible test paths are discovered by traversing the control flow graph using backtracking algorithm, symbolic execution, and Z3 solver. We also generate test cases for functions containing one loop or two-nested loop. A tool supporting the proposed method has been developed and applied to test on some C functions. The experimental results show the high coverage with the minimum number of test cases, the ability to improve the total time of the test case generation with a specified coverage criterion, and the increasing precision of checking the feasibility of test paths if comparing with the random technique. The experimental results display the potential usefulness of this tool for automated test case generation in practice.

An Efficient Method for Automated Generating Models of Component-Based Software

This paper proposes an efficient method for automated generating models of component-based software. This method accepts regular expressions that describe behaviors of software components. The proposed method uses the CNNFA algorithm to parse the regular expressions in order to generate corresponding models. This method can generate minimal accurate models of the software components. A tool is implemented and applied for some typical systems to show the efficiency of this method. The obtained experimental results show that this method is faster than existing methods. The generated models play an important role in making such model-based approaches as model checking and model-based testing more feasible in practice.

An effective framework for assume-guarantee verification of evolving component-based software

This paper proposes an effective framework for the assume-guarantee verification of component-based software in the context of component evolution at system design level. In this framework, when a component is evolved after adapting some refinements, we do not recheck all components in the evolved system, but only the evolved component. For this purpose, if the design model of the evolved component satisfies the current assumption of the system before evolving, the evolved system still satisfies the required property. Otherwise, if the assumption is too strong to be satisfied by the model, a new assumption must be generated again. We propose two methods for regenerating the new assumption called assumption regeneration and minimized assumption regeneration. The methods reuse the assumption to reduce a large number of required membership queries and candidate assumptions which are needed to generate again the new assumption. An implementation and experimental results are presented.

JCIA: A Tool for Change Impact Analysis of Java EE Applications

This paper presents a novel tool for change impact analysis of Java EE applications named JCIA. Analyzing the source code of the Java EE applications is a big challenge because of the complexity and large scale of the applications. Moreover, components in Java EE applications are not only in Java language but also in different languages such as XHTML, XML, JSP. This tool analyzes source code of Java EE applications for building the dependency graphs (called JDG). The main idea for generating JDG is based on developing the source code analyzers for the typical technologies of Java EE such as JavaServer Faces, Context and Dependency Injection, Web services. Based on the obtained JDG and the given change sets, JCIA calculates the corresponding impact sets by applying the change impact analysis (CIA) based on change types and Wave-CIA method. The calculated impact sets help managers in planning and estimating changes, developers in implementing changes, and testers with regression testing.