Location of Repository

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

By Emmanuel Kayode Akinshola Ogunshile


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.\ud \ud 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.\ud \ud 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.\ud \ud 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.\ud \ud 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).\u

Publisher: Computer Science (Sheffield)
Year: 2011
OAI identifier: oai:etheses.whiterose.ac.uk:1215

Suggested articles



  1. (1988). A comparison of some structural testing strategies.
  2. (2000). A Design Language and Tool for X-machine Specification,
  3. (2003). A Formal Method for the Development of Agent Based Systems,
  4. (2003). A Formal Method for the Development of Agent-based Systems.
  5. (2005). A Formal Model for Test Frames, in McMinn, P (ed),
  6. (2005). A formal modelling framework for developing multi-agent systems with dynamic structure and behaviour.
  7. (2004). A framework for detecting redundant objectoriented unit tests.
  8. (1995). A Language with Class: The Theory of Classification Exemplified in an Object-Oriented Programming Language.
  9. (1976). A Machine with Class: A Framework for Object Generation, Integration and Language Authentication (FROGILA)
  10. (2000). A New Approach to Communicating X-Machines Systems,
  11. (1988). A practical method for software quality control via program mutation.
  12. (1988). A specification-based functional testing method for JSP designed programs.
  13. (1996). A State-Based Testing Method for Classes.
  14. (1987). A structural testing method for JSP designed programs.
  15. (2000). A Structured Way to use Channels for Communication in X-Machines Systems. Formal Aspects of Computing,
  16. (2006). A theory of regression testing for behaviourally compatible object types.
  17. (2001). Addressing dynamic issues of program model checking,
  18. (1990). Adequate testing and object-oriented programming.
  19. (1994). An Experiment with Statistical Testing.
  20. (1988). An Extended Domain-Based Model of Software Reliability.
  21. (1997). An Integration Testing Method That is Proved to Find all Faults.
  22. (2002). Automated testing based on Java predicates.
  23. (2005). Automatic generation and classification of test inputs.
  24. (1986). Axiomatizing Software Test Data Adequacy.
  25. (1991). B-Tool Reference Manual.
  26. (2008). Benchmarking effectiveness for object-oriented unit testing,
  27. (2009). Cantata++ for testing C,
  28. (1989). Checking Experiments in Sequential Machines.
  29. (1996). Combining Statecharts and Z for the Design of Safety-critical Systems.
  30. (1999). Communicating Stream X-Machine Systems are no more than X-Machines.
  31. (1996). Communicating X-machines,
  32. (2003). Communicating X-Machines: A Practical Approach for Formal and Modular Specification of Large Systems,
  33. (2003). Communicating X-machines: from theory to practice.
  34. (2004). Complete Deterministic Stream X-machine Testing,
  35. (2001). Complete Functional Testing using Object Machines,
  36. (2001). Computational Models of Collective Foraging,
  37. (1998). COMX: A design methodology using Communicating X-Machines.
  38. (2004). Conformance Testing of Distributed Systems: An X-Machine Based Approach.
  39. (1994). Constructing Functional Test Cases Using Incrementally Derived State Machines.
  40. (2004). Core Java 2: Fundamentals (volume 1). Prentice Hall (ISBN 0131482025),
  41. (1998). Correct Systems: Building a Business Process Solution.
  42. (1994). Design for Testability with Object-Oriented Systems.
  43. (1997). Design-for-Testability for ObjectOriented Software.
  44. (2006). DSD-Crasher: A hybrid analysis tool for bug finding.
  45. (2001). Dynamically discovering likely program invariants to support program evolution,
  46. (2000). Dynamically discovering likely program invariants.
  47. (2004). Efficient incremental algorithms for dynamic detection of likely invariants.
  48. (1992). Estimating the Probability of Failure when Testing Reveals No Failures.
  49. (2008). Feedback-based specification, coding and testing with JWalk,
  50. (2007). Feedback-directed random test generation.
  51. (1997). First Contact.
  52. (1989). Formal Methods for Protocol Testing: a Detailed Study.
  53. (1992). Formal Methods for Test Sequence Generation.
  54. (2002). Formal Modeling of Reactive Agents as an Aggregation of Simple Behaviours,
  55. (1990). Formal specification and design time testing.
  56. (2002). Foundations of the X-machine Theory for Testing.
  57. (2006). From Daikon to Agitator: Lessons and challenges in building a commercial tool for developer testing.
  58. (1974). Functional analysis using cause-effect graphs.
  59. (1987). Functional Program Testing and Analysis.
  60. (1994). Functional Testing of Classes.
  61. (2000). Generating Test Sequences from Non-deterministic Generalized Stream X-Machines.
  62. (1978). Hints on test data selection: Help for the practicing programmer.
  63. (1994). Improving object-oriented analysis.
  64. (1994). Integration Testing for Object-Oriented Software.
  65. (1990). Interest Group in Software Testing. A Standard for Software Component Testing, Issue 1.2, edited by Dorothy Graham and Martyn Ould,
  66. (1989). Interim Defence Standard 00-55, Requirements for the Procurement of Safety Critical Software in Defence Equipment, draft edition,
  67. (1990). Introduction to the Theory of Programming Languages.
  68. (1994). Issues in the Testing of Object-oriented Software.
  69. (2004). JCrasher: An automatic robustness tester for Java.
  70. (2008). jStar: Towards Practical Verification for Java.
  71. (2007). JWalk: a tool for lazy systematic testing of Java classes by introspection and user interaction,
  72. (2007). Lazy systematic unit testing: JWalk versus JUnit,
  73. (1996). Let’s Agree on the Meaning of Class.
  74. (2003). Model checking programs.
  75. (1991). Modular Specification and Verification of Object-Oriented Programs.
  76. Mutation testingan evolving technique.
  77. (1994). Object-Oriented Analysis and Design with Applications. Benjamin-Cummings,
  78. (1991). Object-Oriented Design with Applications. Benjamin-Cummings,
  79. (1990). Object-Oriented Programming: The Problems of Validation.
  80. (1997). Object-Oriented Software Construction. Englewood Cliffs,
  81. (1997). Object-Oriented Software Construction. Second edition,
  82. (1993). On Object State Testing.
  83. (2009). Parasoft JTest ® product description,
  84. (1990). Partition Testing Does Not Inspire Confidence.
  85. (1985). Principles of OBJ2,
  86. (1990). Programming From Specifications.
  87. (1993). Selecting Functional Test Cases for a Class. In
  88. (2003). Simulation and Verification of P Systems through Communicating X-Machines,
  89. (1998). Specification and Testing Using Generalized Machines: a Presentation and a Case Study, Software Testing, Verification and Reliability,
  90. (1986). Specification directed module testing.
  91. (1993). Specifications and their use in defining sub-types.
  92. (1987). Statecharts: a Visual Formalism for Complex Systems.
  93. (2005). Symstra: A framework for generating object-oriented unit tests using symbolic execution.
  94. (2002). Systems of Communicating X-machines for Specifying Distributed Systems.
  95. (1997). Test selection for specification-based testing of object-oriented software based on formal specifications.
  96. (1991). Testability of Software Components.
  97. (2004). Testing Conformance of a Deterministic Implementation Against a Non-deterministic Stream X-machine.
  98. (2000). Testing Conformance to a Quasi-non-deterministic Stream X-machine.
  99. (1996). Testing Object-Oriented Software: A Survey.
  100. (1993). Testing Object-Oriented Software.
  101. (1992). Testing Object-Oriented Software. Advanced Technology Specialists,
  102. (1995). Testing Objects: Myth and Reality. Object Magazine,
  103. (1994). Testing of Object-Oriented Programming Systems (OOPS): A Fault-Based Approach.
  104. (1995). Testing of Object-Oriented Programs Based on Finite State Machines.
  105. (1978). Testing Software Design Modelled by Finite State Machines.
  106. (1989). Testing the completeness of specifications.
  107. (2001). Testing the Polymorphic Relationships of Object-Oriented Programs,
  108. (2005). Testing with guarantees and the failure of regression testing in eXtreme Programming.
  109. (1979). The art of software testing, Publication info:
  110. (1988). The category-partition method for specifying and generating functional tests.
  111. (2005). The Category-Partition Method,
  112. (2007). The Daikon system for dynamic detection of likely invariants,
  113. (1988). The Evaluation of Program-Based Software Test Data Adequacy Criteria.
  114. (1996). The FREE Approach for System Testing: Use-Cases, Threads, and Relations.
  115. (1988). The growth of software testing.
  116. (2004). The JUnit Pocket Guide, 1st edn.
  117. (2009). The JUnit project website. http://www.junit.org/.
  118. (1994). The Problematics of Testing Object-Oriented Software.
  119. (1993). The Theory and Practice of Specification Based Software Testing.
  120. (1980). Theories of Program Testing and the Applications of Revealing Subdomains.
  121. (1995). Theory of X-machines and Applications in Specification and Testing,
  122. (2003). Tool-assisted unit test selection based on operational violations.
  123. (1975). Toward a theory of test data selection.
  124. (1996). Translating Statecharts and µSZ specifications into Xmachines.
  125. (1995). Trends in Testing Object-Oriented Software.
  126. (2007). Unified Modeling Language, version 1.1, http://www.omg.org/cgi-bin/doc?ad/97-08-11. Accessed
  127. (1995). Using an Xmachine to model a Video Cassette Recorder. Current issues in Electronic Modeling,
  128. (1982). Weak mutation testing and completeness of test sets.

To submit an update or takedown request for this paper, please submit an Update/Correction/Removal Request.