Testing object‐oriented software: a survey

Component Completeness Checklng Formal Verlflca tlon Component Implementation T Fo rrn al Artifacts Informal Artifacts Behavior Figure 3. ADT artifacts cind verification techniques TESTING OBJECT-ORIENTED SOFTWARE 135 et al., 1981; Dauchy et al., 1993; Doong and Frankl, 1994). Relationships among axioms can be exploited to generate test sequences and test case data (Bougt et al., 1986; Choquet, 1986; Gaudel and Marre, 1988; Bemot et al., 1991; Dauchy et al., 1993; Doong and Frankl, 1994). Most ADT test approaches generate operation sequences which are hoped to be faultrevealing (Jalote and Caballero, 1988; Jalote, 1992; Zweben et al., 1992; Parrish et al., 1993b; Doong and Frankl, 1994). Tests using model-based specifications select sequences by analysing define-use relationships among exported operations (Zweben et al., 1992; Parrish et al., 1993b). A coverage measure may be derived from such a test suite. In contrast, tests using algebraic specifications make use of constraints on operations (axioms) to select paths by a substitution process. Automated support for model validation and consistency checking is discussed in Section 4. Product validation is not discussed here as it can be accomplished by established methods which are not specific to ADTs or object-oriented development. 2.2. Formal verification 2.2.1. Prover’s assistant An early presentation of the ADT approach argues that algebraic specification facilitates proofs by factoring complexity and allowing automated support. ‘Writing the axioms in a certain style allows them to be used as reduction rules so that proofs become largely symbol manipulation exercises.’ (Guttag et al., 1978, p. 1062). ‘Testing’ uses a direct implementation input to the ‘data type verification system’ (DTVS). A direct implementation for data type T is an ‘implementation whose representation part is a subset of the syntactic specification of T and whose program part is a subset of the semantic specification of T.’ (Guttag et al., 1978, p. 1059). The verification process has three steps: ( 1 ) input the specification and implementation to DTVS; (2) use DTVS to generate axioms and equality axioms for the specification (verification conditions); (3) the user attempts to prove the verification conditions, using an automated support for substitution of previously established results. This process is reported to be useful for discovering missing assumptions. The tool keeps track of proofs and does some syntactic checking.

[1]  Xiaoping Jia Model-based formal specification directed testing of abstract data types , 1993, Proceedings of 1993 IEEE 17th International Computer Software and Applications Conference COMPSAC '93.

[2]  John D. Gannon,et al.  Evaluating a data abstraction testing system based on formal specifications , 1981, J. Syst. Softw..

[3]  Marie-Claude Gaudel,et al.  Using algebraic specifications in software testing: A case study on the software of an automatic subway , 1993, J. Syst. Softw..

[4]  Jane Huffman Hayes Testing of Object-Oriented Programming Systems (OOPS): A Fault-Based Approach , 1994, ISOOMS.

[5]  Bertrand Meyer,et al.  Applying 'design by contract' , 1992, Computer.

[6]  Richard G. Hamlet,et al.  Partition Testing Does Not Inspire Confidence , 1990, IEEE Trans. Software Eng..

[7]  D. J. Robson,et al.  State-Based Testing and Inheritance , 1993 .

[8]  Philippe Desfray,et al.  Object engineering - the fourth dimension , 1994 .

[9]  Phyllis G. Frankl,et al.  Case studies on testing object-oriented programs , 1991, TAV4.

[10]  David A. Taylor A quality-first program for object technology , 1992 .

[11]  David Cordes,et al.  Developmental testing of abstract data types , 1993, Proceedings of 1993 IEEE 17th International Computer Software and Applications Conference COMPSAC '93.

[12]  Jean-Marc Nerson,et al.  Object-Oriented Analysis and Design , 1992, TOOLS.

[13]  Roy S. Freedman,et al.  Testability of Software Components , 1991, IEEE Trans. Software Eng..

[14]  Stephen J. Mellor,et al.  Object Oriented Systems Analysis: Modeling the World in Data , 1988 .

[15]  Daniel Hoffman,et al.  A case study in class testing , 1993, CASCON.

[16]  Stephen J. Mellor,et al.  Object lifecycles: modeling the world in states , 1992 .

[17]  Steven P. Reiss,et al.  Support for Maintaining Object-Oriented Programs , 1992, IEEE Trans. Software Eng..

[18]  Norman Wilde,et al.  Maintaining object-oriented software , 1993, IEEE Software.

[19]  Elliot Soloway,et al.  Designing documentation to compensate for delocalized plans , 1988, CACM.

[20]  James J. Horning,et al.  The Larch Family of Specification Languages , 1985, IEEE Software.

[21]  Laurent Fribourg,et al.  Test sets generation from algebraic specifications using logic programming , 1986, J. Syst. Softw..

[22]  Edward V. Berard,et al.  Testing Object-Oriented Software , 2021, TOOLS.

[23]  Phyllis G. Frankl,et al.  The ASTOOT approach to testing object-oriented programs , 1994, TSEM.

[24]  David Thielen No Bugs!: Delivering Error Free Code in C and C++ , 1992 .

[25]  Elmer S. West From the U. S. A. , 1965 .

[26]  David Harel,et al.  On visual formalisms , 1988, CACM.

[27]  John D. Mcgregor Constructing functional test cases using incrementally de~ned state machines , 1994 .

[28]  Karl J. Lieberherr,et al.  Assuring good style for object-oriented programs , 1989, IEEE Software.

[29]  Douglas R. Smith,et al.  Transformational approach to transportation scheduling , 1993, Proceedings of 8th Knowledge-Based Software Engineering Conference.

[30]  Randy Shepherd,et al.  Object-Oriented Programming , 1994, Lecture Notes in Computer Science.

[31]  Anas N. Al-Rabadi,et al.  A comparison of modified reconstructability analysis and Ashenhurst‐Curtis decomposition of Boolean functions , 2004 .

[32]  John D. McGregor,et al.  Object-oriented software development - engineering software for reuse , 1992, VNR computer library.

[33]  D. J. Robson,et al.  Object-oriented programming-the problems of validation , 1990, Proceedings. Conference on Software Maintenance 1990.

[34]  Gail C. Murphy,et al.  Experiences with cluster and class testing , 1994, CACM.

[35]  Sallie M. Henry,et al.  Object-oriented metrics that predict maintainability , 1993, J. Syst. Softw..

[36]  B. H. Liskov,et al.  Specification techniques for data abstractions , 1975, IEEE Transactions on Software Engineering.

[37]  Markku Sakkinen On the Darker Side of C++ , 1988, ECOOP.

[38]  Gail C. Murphy,et al.  Towards a testing methodology for object-oriented systems , 1993, OOPS Messenger.

[39]  Richard J. LeBlanc,et al.  Class Testing by Examining Pointers , 1994, J. Object Oriented Program..

[40]  Daniel Hoffman,et al.  Graph-based Class Testing , 1994, Aust. Comput. J..

[41]  Glenford J. Myers,et al.  Art of Software Testing , 1979 .

[42]  Trucy Levine Reusable software components , 1997, ALET.

[43]  Donald Firesmith Object-oriented requirements analysis and logical design - a software engineering approach , 1993, Wiley professional computing.

[44]  Richard G. Hamlet,et al.  Data Abstraction, Implementation, Specification, and Testing , 1981, TOPL.

[45]  D. J. Robson,et al.  The Testing of Object-Oriented Programs , 1993 .

[46]  John D. Musa,et al.  Operational profiles in software-reliability engineering , 1993, IEEE Software.

[47]  Karl J. Lieberherr,et al.  Object-Oriented Software Evolution , 1993, IEEE Trans. Software Eng..

[48]  H E Solberg,et al.  Object-oriented methods. , 1993, Clinica chimica acta; international journal of clinical chemistry.

[49]  William F. Ogden,et al.  Modular Verification of Data Abstractions with Shared Realizations , 1994, IEEE Trans. Software Eng..

[50]  N. P. Capper,et al.  The Impact of Object-Oriented Technology on Software Quality: Three Case Histories , 1994, IBM Syst. J..

[51]  Tetsuo Tamai Formal and informal approaches for validation , 1991, [1991] Proceedings The Fifteenth Annual International Computer Software & Applications Conference.

[52]  Grady Booch,et al.  Object-Oriented Design with Applications , 1990 .

[53]  David H. Taenzer,et al.  Problems in Object-Oriented Software Reuse , 1989, ECOOP.

[54]  Adele Goldberg,et al.  SmallTalk 80: The Language , 1989 .

[55]  John D. McGregor,et al.  Integrated object-oriented testing and development processes , 1994, CACM.

[56]  Derek Coleman,et al.  Formal Specification and Design Time Testing , 1990, IEEE Trans. Software Eng..

[57]  D. J. Robson,et al.  A framework for testing object-oriented programs , 1992 .

[58]  Wei-Tek Tsai,et al.  Method Sequence Specification and Verification of Classes , 1994, Journal of object-oriented programming.

[59]  Pamela Zave,et al.  An Insider's Evaluation of PAISLey , 1991, IEEE Trans. Software Eng..

[60]  Brad J. Cox,et al.  Planning the software industrial revolution , 1990, IEEE Software.

[61]  Bran Selic,et al.  Real-time object-oriented modeling , 1994, Wiley professional computing.

[62]  Gregg Rothermel,et al.  Selecting regression tests for object-oriented software , 1994, Proceedings 1994 International Conference on Software Maintenance.

[63]  Betty P. Chao,et al.  Applying software testing practices to an object-oriented software development , 1993, OOPSLA '93.

[64]  Richard A. Kemmerer,et al.  Testing Formal Specifications to Detect Design Errors , 1985, IEEE Transactions on Software Engineering.

[65]  Chris F. Kemerer,et al.  A Metrics Suite for Object Oriented Design , 2015, IEEE Trans. Software Eng..

[66]  M.-C. Gaudel,et al.  Generation of test data from algebraic specifications , 1988, [1988] Proceedings. Second Workshop on Software Testing, Verification, and Analysis.

[67]  Elaine J. Weyuker,et al.  The evaluation of program-based software test data adequacy criteria , 1988, CACM.

[68]  D. J. Robson,et al.  Guidance for the Testing of Object-Oriented Programs , 1993 .

[69]  Walter G. Olthoff Augmentation of Object-Oriented Programming by Concepts of Abstract Data Type Theory: The ModPascal Experience , 1986, OOPSLA.

[70]  Chris Dollin,et al.  Object-oriented development: the fusion method , 1994 .

[71]  Bjarne Stroustrup,et al.  The Design and Evolution of C , 1994 .

[72]  Cyrille Gindre,et al.  A development in Eiffel: design and implementation of a network simulator , 1989 .

[73]  David W. Embley,et al.  Object-oriented systems analysis - a model-driven approach , 1991, Yourdon Press Computing series.

[74]  Ian J. Hayes,et al.  Specification directed module testing , 1986, IEEE Transactions on Software Engineering.

[75]  Thomas J. Cheatham,et al.  Testing object-oriented software systems , 1990, CSC '90.

[76]  Gail E. Kaiser,et al.  Adequate testing and object-oriented programming , 1990 .

[77]  Brad J. Cox,et al.  Object-oriented programming ; an evolutionary approach , 1986 .

[78]  Pankaj Jalote,et al.  Automated testcase generation for data abstraction , 1988, Proceedings COMPSAC 88: The Twelfth Annual International Computer Software & Applications Conference.

[79]  John D. McGregor,et al.  A note on inheritance and state machines , 1993, SOEN.

[80]  David Cordes,et al.  Automated flow graph-based testing of object-oriented software modules , 1993, J. Syst. Softw..

[81]  Matthew Pittman,et al.  Lessons learned in managing object-oriented development , 1993, IEEE Software.

[82]  John D. McGregor,et al.  Incremental testing of object-oriented class structures , 1992, ICSE '92.

[83]  David Chenho Kung,et al.  On object state testing , 1994, Proceedings Eighteenth Annual International Computer Software and Applications Conference (COMPSAC 94).

[84]  David J. Robson,et al.  The state-based testing of object-oriented programs , 1993, 1993 Conference on Software Maintenance.

[85]  Chi-Ming Chung,et al.  Object-oriented programming testing methodology , 1992, Proceedings Fourth International Conference on Software Engineering and Knowledge Engineering.

[86]  Chyan-Goei Chung,et al.  A structural testing method for C++ programs , 1994, Proceedings Eighteenth Annual International Computer Software and Applications Conference (COMPSAC 94).

[87]  Mary Shaw,et al.  Abstraction Techniques in Modern Programming Languages , 1984, IEEE Software.

[88]  Ellis Horowitz,et al.  Abstract data types and software validation , 1978, CACM.