State-based testing - a new method for testing object-oriented programs

State-based testing is a new method for testing object-oriented programs. The information stored in the state of an object is of two kinds: control-information and data-storage. The control-information transitions are modelled as a finite state automaton. Every operation of the class under test is considered as a mapping from starting states to a finishing states dependent upon the parameters passed. The possible parameter values are analysed for significant values which combined with the invocation of an operation can be used to represent stimuli applied to an object under test. State-based testing validates the expected transformations that can occur within a class. Classes are modelled using physical values assigned to the attributes of the class. The range of physical values is reduced by the use of a technique based on equivalence partitioning. This approach has a number of advantages over the conceptual modelling of a class, in particular the ease of manipulation of physical values and the independence of each operation from the other operations provided by an object. The technique when used in conjunction with other techniques provides an adequate level of validation for object-oriented programs. A suite of prototype tools that automate the generation of state-based test cases are outlined. These tools are used in four case studies that are presented as an evaluation of the technique. The code coverage achieved with each case study is analysed for the factors that affect the effectiveness of the state-based test suite. Additionally, errors have been seeded into 2 of the classes to determine the effectiveness of the technique for detecting errors on paths that are executed by the test suite. 92.5% of the errors seeded were detected by the state-based test-suite

Model Based Distributed Testing of Object Oriented Programs

AbstractIn recent times the software systems have evolved in size and complexity. This has resulted in usage of object oriented programming in the development of such systems. Though object oriented programs are helpful in programming large systems, testing of such systems requires much more effort and time. For this the program is analyzed to create a model based on System Dependence Graph(SDG) which is then used to find locations within the program where the state of the program can be freezed and reused while executing other test cases

A Machine With Class: A Framework for Object Generation, Integration and Language Authentication (FROGILA)

The object technology model is constantly evolving to address the software crisis problem. This novel idea which informed and currently guides the design style of most modern scalable software systems has caused a strong belief that the object-oriented technology is the ultimate answer to the software crisis, i.e. applying an object-oriented development method will eventually lead to quality code. It is important to emphasise that object-orientedness does not make testing obsolete. As a matter of fact, some aspects of its very nature introduce new problems into the production of correct programs and their testing due to paradigmatic features like encapsulation, inheritance, polymorphism and dynamic binding as this research work shows. Most work in testing research has centred on procedure-oriented software with worthwhile methods of testing having been developed as a result. However, those cannot be applied directly to object-oriented software owing to the fact that the architectures of such systems differ on many key issues. In this thesis, we investigate and review the problems introduced by the features of the object technology model and then proceed to show why traditional structured software testing techniques are insufficient for testing object-oriented software by comparing the fundamental differences in their architecture. Also, by reviewing Weyuker’s test adequacy axioms we show that program-based testing and specification-based testing are orthogonal and complementary. Thus, a software testing methodology that is solely based on one of these approaches (i.e. program-based or specification-based testing) cannot adequately cover all the essential paths of the system under test or satisfactorily guarantee correctness in practice. We argue that a new method is required which integrates the benefits of the two approaches and further builds upon their individual strengths to create a more meaningful, practical and reliable solution. To this end, this thesis introduces and discusses a new automaton-based framework formalism for object-oriented classes called the Class-Machine and a test method that is based on this formalism. Here, the notion of a class or the idea behind classification in object-oriented languages is embodied within a machine framework. The Class-Machine model represents a polymorphic abstraction for heterogeneous families of Object-Machines that model a real life problem in a given domain; these Object-Machines are instances of different concrete machine types. The Class-Machine has an extensible machine implementation as well as an extensible machine interface. Thus, the Class-Machine is introduced as a formal framework for generating autonomous Object-Machines (i.e. Object-Machine Generator) that share common Generic Class-Machine States and Specific Object-Machine States. The states of these Object-Machines are manipulated by a set of processing functions (i.e. Class-Machine Methods and Object-Machine Methods) that must satisfy a set of preconditions before they are allowed to modify the state(s) of the Object-Machines. The Class-Machine model can also be viewed as a platform for integrating a society of communicating Object-Machines. To verify and completely test systems that adhere to the Class-Machine framework, a novel testing method is proposed i.e. the fault-finders (f²) - a distributed family of software checkers specifically designed to crawl through a Class-Machine implementation to look for a particular type of fault and tell us the location of the fault in the program (i.e. the class under test). Given this information, we can statistically show the distribution of faults in an object-oriented system and then provide a probabilistic assertion of the number and type of faults that remain undetected after testing is completed. To address the problems caused through the encapsulation mechanism, this thesis introduces and discusses another novel framework formalism that has complete visibility on all the encapsulated methods, memory states of the instance and class variables of a given Object-Machine or Class-Machine system under test. We call this the Class Machine Friend Function (CMƒƒ). In order to further illustrate all the fundamental theoretical ideas and paradigmatic features inherent within our proposed Class-Machine model, this thesis considers four different Class-Machine case studies. Finally, to further show that the Class-Machine theoretical purity does not mitigate against practical concerns, our novel object-oriented specification, verification, debugging and testing approaches proposed in this thesis are exemplified in an automated testing tool called: The Class-Machine Testing Tool (CMTT)

A study on test cases generation for object-oriented programs based on UML state diagram.

Software testing expenses are estimated to be between 20% and 50% of total development costs. Software testers need methodologies and tools to facilitate the testing portion of the development cycle. State-based testing is one of the most recommended techniques for testing object-oriented programs. Data flow testing is a code-based testing technique, which uses the data flow analysis in a program to guide the selection of test cases. Both state-based testing and data flow testing have their disadvantages. State-based testing does not analyze the program code, and thus could miss the detection of data members that do not define the states of the object class. Selecting data flow test cases from data members for testing classes is difficult and expensive. To overcome their weakness, a hybrid class test model is proposed, which contains both the information from specification about the state change of object instances of the Class Under Test (CUT) and the information from the source code about the definition and use of the data members in the CUT. With such an uniformed architecture, we can obtain automated tools to generate test cases for state-based testing and perform data flow testing at the same time. The combination of the two techniques is essential in improving our testing environment, and thus contributes to the enhancement of the reliability of software products. The proposed hybrid testing strategy can be used in both software design stage and software implementation stage. A Standard-based UML information exchange format, XMI is used to describe UML design specification in the hybrid testing strategy, to bridge the software designer and software tester. No matter what kind of CASE tools designer use, as long as it is saved as XMI format, the testing tool can easily understand design specification from different design tools. Paper copy at Leddy Library: Theses & Major Papers - Basement, West Bldg. / Call Number: Thesis2001 .Y36. Source: Masters Abstracts International, Volume: 40-03, page: 0730. Adviser: Xiaojun Chen. Thesis (M.Sc.)--University of Windsor (Canada), 2001

Ferramenta de apoio ao teste de aplicações java baseada em reflexão computacional

A atividade de teste constitui uma fase de grande importância no processo de desenvolvimento de software, tendo como objetivo garantir um alto grau de confiabilidade nos produtos desenvolvidos. Com o advento do paradigma da orientação a objetos, novos problemas foram introduzidos na atividade de teste de programas, tornando-a mais complexa do que para sistemas tradicionais. Com o objetivo de auxiliar o processo de teste de programas orientados a objetos, este trabalho aborda o desenvolvimento de uma ferramenta, para programas escritos em Java, orientada ao teste de estados com apoio da tecnologia de reflexão computacional. Através do emprego de asserções, especificadas pelo usuário, é possível verificar a integridade dos estados dos objetos durante a execução do programa em teste.Software testing is a very important step in the software development cycle, whose goal is the obtainment of systems with a high degree of reliability. With the advent of the object oriented paradigm, new problems have been introduced in the software testing activity, by making it more complex than the traditional procedural validation. This paper focuses on the development of a tool to support the testing process of object oriented programs. KTest is oriented to state-based testing of Java-written programs, supported by the mechanism of computational reflection. By evaluating user specified assertions, KTest verifies the state integrity of the objects during the execution of the program being tested.Eje: Ingeniería de softwareRed de Universidades con Carreras en Informática (RedUNCI

Ferramenta de apoio ao teste de aplicações java baseada em reflexão computacional

A atividade de teste constitui uma fase de grande importância no processo de desenvolvimento de software, tendo como objetivo garantir um alto grau de confiabilidade nos produtos desenvolvidos. Com o advento do paradigma da orientação a objetos, novos problemas foram introduzidos na atividade de teste de programas, tornando-a mais complexa do que para sistemas tradicionais. Com o objetivo de auxiliar o processo de teste de programas orientados a objetos, este trabalho aborda o desenvolvimento de uma ferramenta, para programas escritos em Java, orientada ao teste de estados com apoio da tecnologia de reflexão computacional. Através do emprego de asserções, especificadas pelo usuário, é possível verificar a integridade dos estados dos objetos durante a execução do programa em teste.Software testing is a very important step in the software development cycle, whose goal is the obtainment of systems with a high degree of reliability. With the advent of the object oriented paradigm, new problems have been introduced in the software testing activity, by making it more complex than the traditional procedural validation. This paper focuses on the development of a tool to support the testing process of object oriented programs. KTest is oriented to state-based testing of Java-written programs, supported by the mechanism of computational reflection. By evaluating user specified assertions, KTest verifies the state integrity of the objects during the execution of the program being tested.Eje: Ingeniería de softwareRed de Universidades con Carreras en Informática (RedUNCI

A Fitness Function for Search-based Testing of Java Classes, which is Based on the States Reached by the Object under Test

Genetic Algorithms are among the most efficient search-based techniques to automatically generate unit test cases today. The search is guided by a fitness function which evaluates how close an individual is to satisfy a given coverage goal. There exists several coverage criteria but the default criterion today is branch coverage. Nevertheless achieving high or full branch coverage does not imply that the generated test suite has good quality. In object oriented programs the state of the object affects its behavior. Thereupon, test cases that put the object under test, in new states are of interest in the testing context. In this article we propose a new fitness function which takes into consideration three factors for evaluation: the approach level, the branch distance and the new states reached by a test case. The coverage targets are still the branches, but during the search, the state of the object under test evolves with the scope to produce individuals that discover interesting features of the class and as a consequence can discover errors. We implemented this fitness function in the eToc tool. In our experiments the usage of the proposed fitness function towards the original fitness function results in a relative increase of 15.6% in the achieved average mutation score with the cost of a relative increase of 12.6% in the average test suite size

Towards Practical Graph-Based Verification for an Object-Oriented Concurrency Model

To harness the power of multi-core and distributed platforms, and to make the development of concurrent software more accessible to software engineers, different object-oriented concurrency models such as SCOOP have been proposed. Despite the practical importance of analysing SCOOP programs, there are currently no general verification approaches that operate directly on program code without additional annotations. One reason for this is the multitude of partially conflicting semantic formalisations for SCOOP (either in theory or by-implementation). Here, we propose a simple graph transformation system (GTS) based run-time semantics for SCOOP that grasps the most common features of all known semantics of the language. This run-time model is implemented in the state-of-the-art GTS tool GROOVE, which allows us to simulate, analyse, and verify a subset of SCOOP programs with respect to deadlocks and other behavioural properties. Besides proposing the first approach to verify SCOOP programs by automatic translation to GTS, we also highlight our experiences of applying GTS (and especially GROOVE) for specifying semantics in the form of a run-time model, which should be transferable to GTS models for other concurrent languages and libraries.Comment: In Proceedings GaM 2015, arXiv:1504.0244