Ogunshile, Emmanuel Kayode Akinshola (2011) A Machine With Class: A Framework for Object Generation, Integration and Language Authentication (FROGILA). PhD thesis, University of Sheffield.
Available under License Creative Commons Attribution-Noncommercial-No Derivative Works 2.0 UK: England & Wales.
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).
|Item Type:||Thesis (PhD)|
|Academic Units:||The University of Sheffield > Faculty of Engineering (Sheffield) > Computer Science (Sheffield)
The University of Sheffield > Faculty of Science (Sheffield) > Computer Science (Sheffield)
|Depositing User:||Dr Emmanuel Kayode Akinshola Ogunshile|
|Date Deposited:||02 Feb 2011 11:56|
|Last Modified:||27 Apr 2016 14:11|