Method and apparatus for software testing using a differential testing technique to test compilers

• US 5,754,860 A
• Filed: 07/23/1996
• Issued: 05/19/1998
• Est. Priority Date: 07/23/1996
• Status: Expired due to Term

• Current Assignee: Hewlett Packard Enterprise Development LP (Hewlett-Packard Enterprise Company)
• Original Assignee: Digital Equipment Corporation (HP Inc.)
• Inventors: McKeeman, William M., Payne, Andrew, Reinig, August C.
• Primary Examiner(s): Kriess, Kevin A.
• Application Number:
  US08/685,346
• Time in Patent Office: 665 Days
• Field of Search: 395/704, 395/701, 395/705, 395/183.14, 364/551.01, 364/570, 364/580, 364/582
• US Class Current: 717/124
• CPC Class Codes: G06F 11/3684 for test design, e.g. generating new test cases

Abstract

Techniques used in testing software are described. A test generator produces a source program used to test two or more compilers using a differential testing technique. The test generator includes a grammar with added semantic constraints to minimize the generation of non-conforming source programs. The source program is a conforming source program conforming to constraints included in a programming language standard. By using properties of a conforming source code, a differential testing technique is described in which a test failure indicates that one or more of the compilers is not processing the source program correctly in accordance with the programming language standard. If a test failure is detected, the source program causing the test failure is reduced using various reduction and simplification techniques.

Claims

1. A method executed in a computer system for testing machine executable programs, the method comprising the steps of:

generating a test program;

producing, using said test program and a first language processor, a first corresponding machine executable;

producing, using said first corresponding machine executable, a first output;

producing, using said test program and a second language processor, a second corresponding machine executable;

producing, using said second corresponding machine executable, a second output;

determining if there is a difference between said first and said second outputs; and

detecting a test failure if there is a difference between said first and second outputs and said test program conforms to a runtime constraint included in a standard specifying how a machine executable produced using said test program behaves if said test program conforms to constraints included in said standard, said constraints including said runtime constraint, said test failure indicating that one of said first or second language processors is not in compliance with said standard.

2. The method of claim 1 wherein said test program is a source program including statements of a programming language, said source program conforming to a portion of predetermined constraints including syntactic constraints, semantic constraints, and said runtime constraint defined in accordance with a programming language standard for said programming language, said first and second language processors are, respectively, first and second compilers each associated with processing said programming language, and said first and second outputs are runtime results produced by executing, respectively, said first corresponding and said second corresponding machine executables, said method further including the steps of:

compiling said source program with said first compiler producing a first object file;

linking said first object file producing said first corresponding machine executable;

compiling said source program with said second compiler producing a second object file;

linking said second object file producing said second corresponding machine executable;

executing a runtime conformance checker to determine if said test program conforms to said runtime constraint; and

if there is a difference between said first and second outputs, examining said first and second compilers to determine if there is a problem with one of said first and second compilers.

3. The method of claim 2 wherein said second compiler is an optimized version of said first compiler.

4. The method of claim 2 wherein said first compiler is associated with a first platform and said second compiler is associated with a second platform different from said first platform, each of said first and second platforms corresponding to an operating system and a hardware platform.

5. The method of claim 2 wherein said source program is generated using a generator which includes a grammar used to produce source programs comprising one or more statements of said programming language, said grammar comprising:

initial grammar rules defining said programming language and describing statements of said programming language in conformance with another portion of said predetermined constraints;

one or more nonterminal symbols;

one or more terminal symbols; and

additional grammar rules which are dynamically added to said initial set of grammar rules during generation of said source program;

and wherein said source program includes statements corresponding to a portion of said terminal symbols, each of said statements being derived by randomly selecting one of said initial or one of said additional grammar rules during expansion of one of said nonterminal symbols.

6. The method of claim 5, wherein said first compiler resides in a first computer system, said second compiler resides in a second computer system, and said test generator resides in a third computer system, said first, second, and third computer systems communicating over a network.

7. The method of claim 1, wherein said test program is a source program including statements of a programming language, said test program conforms to a portion of predetermined constraints including syntactic constraints, semantic constraints, and said runtime constraint defined in accordance with a programming language standard for said programming language, said first and second language processors are, respectively, first and second compilers each associated with said programming language, and said first and second outputs are runtime results from executing, respectively, said first corresponding and said second corresponding machine executables, said method further including the steps of:

performing runtime conformance checking of said test program to determine if said test program corresponds to said runtime constraint; and

reducing said test program to produce a reduced input if it is determined that said test program meets said runtime constraint and if a difference is determined between said first and second outputs.

8. The method of claim 7, wherein said test program is a first test program and said step of reducing said test program includes the steps of:

formatting said test program producing a second test program, wherein a line of said first test program corresponds to one or more lines in said second test program;

deleting one or more lines of said second test program if, by deleting said one or more lines of said second test program, said test failure reproduces;

simplifying one or more lines of said second test program by replacing a first language element of said programming language with a second language element of said programming language if, by simplifying said second test program, said test failure reproduces, said second language element being simpler than said first language element; and

repeating said deleting step.

9. The method of claim 8, wherein said deleting step includes the steps of:

deleting one line of said second test program;

determining, in response to said step of deleting one line, if said test failure is reproducible using said second test program;

replacing, in response to determining that said test failure is not reproducible, the one line deleted in said deleting step;

repeating said deleting, said determining and said replacing steps for each line of said second test program beginning with said last line of said second test program if said programming language requires that an identifier be declared prior to use within said second test program.

10. The method of claim 8, wherein said step of reducing said test program further includes the steps of:

reformatting said second test program making said second test program more readable.

11. The method of claim 8, wherein said step of simplifying said second test program includes, performing upon said first test program, the steps of:

removing a block statement;

replacing a compound statement with a simpler statement;

removing parenthesis from an expression;

shorten a literal;

replace an identifier with a literal;

removing an operator and corresponding operand from an expression; and

removing a record type definition.

12. A method of generating a source program including statements of a programming language, said method comprising the steps of:

expanding a nonterminal symbol of a grammar in accordance with grammar rules included in said grammar by selecting one or more of said grammar rules, said grammar rules defining said programming language and describing statements of said programming language wherein said statements are in conformance with a portion of a predetermined number of constraints, said grammar including one or more nonterminal symbols and one or more terminal symbols, each of said grammar rules specifying a mapping for one of said nonterminal symbols to one or more of said nonterminal and said terminal symbols;

dynamically modifying one of said grammar rules in response to one of said grammar rules selected in said expanding step;

dynamically adding a new rule to said grammar rules in response to one of said grammar rules selected in said expanding step;

repeating said expanding step until all nonterminal symbols have been expanded producing a derived string of terminal symbols; and

producing said source program using said derived string.

13. The method of claim 12 further including step of:

associating a probability for selection with each of said grammar rules determining the probability with which said rule is selected during said step of expanding said nonterminal.

14. The method of claim 12 wherein said new rule is selected during said expanding step.

15. The method of claim 12 wherein said grammar rules include a portion of grammar rules initially produced, said method further including the steps of:

describing base type constraints of said programming language in said portion of grammar rules;

describing literal constraints of said programming language in said portion of grammar rules; and

describing expression constraints of said programming language in said portion of grammar rules, said expression constraints reflecting assignment statement restrictions defined in accordance with said programming language.

16. The method of claim 15, wherein said expression constraints include left value expression constraints and right value expression constraints, said left value expression constraints describing expressions assigned a value/modified, said right hand expression constraints describing expressions whose values are assigned to one of said left value expressions.

17. The method of claim 12, wherein, in response to a first grammar rule being selected in said expanding step, said step of dynamically modifying a second grammar rule adds a new identifier to said first grammar rule, said new identifier being one of said terminal symbols, said first grammar rule referencing an identifier when no identifiers are available for use and causing the declaration of said new identifier which is dynamically added to said grammar by modifying said second grammar rule.

18. The method of claim 12, wherein, in response to a first grammar rule being selected in said expanding step, said step of dynamically adding a new rule to said grammar rules adds said new rule describing constraints of a derived type, said derived type being associated with a base type defined in said programming language, wherein, prior to adding said new rule, said grammar rules do not describe said derived type.

19. A test generator comprising:

a grammar including;

grammar rules defining a language and describing statements of said language wherein said statements conform to a portion of predetermined constraints, said predetermined constraints including syntactic and semantic constraints,

one or more nonterminal symbols, said grammar rules providing a definition for a portion of said nonterminal symbols, and

one or more terminal symbols used to define said nonterminal symbols;

means, coupled to said grammar, for expanding a nonterminal symbol to derive a set of one or more terminal symbols by selecting one or more of said grammar rules;

means, coupled to said expanding means and said grammar, for dynamically modifying one of said grammar rules while expanding a selected one of said nonterminal symbols;

means, coupled to said expanding means and said grammar, for dynamically adding one or more grammar rules while expanding a nonterminal; and

a source code producer for generating a test using said set of terminal symbols derived from a portion of said grammar rules selected.

20. The test generator of claim 19 wherein said test generator further includes:

a random number generator for generating a random number;

means for associating a probability with each of said grammar rules;

and wherein said expanding means includes;

selecting means, coupled to said random number generator, for selecting one of said grammar rules in accordance with probabilities associated with said grammar rules.

21. The test generator of claim 20 wherein a second version of said test is generated using said generator and said generator includes a first grammar used to produce said test and a second grammar used to generate said second version.

22. The test generator of claim 20 further including:

means for dynamically modifying probabilities associated with said grammar rules in response to selection of one of said grammar rules.

23. A method executed in a computer system for testing software, said method comprising the steps of:

generating a first machine executable using a first source program and software being tested;

generating first execution results by executing said first machine executable;

generating a second machine executable using a second source program and said software being tested, said second source program being an equivalent version of said first source program;

generating second execution results by executing said second machine executable; and

comparing said first and second execution results to determine if there is a problem in said software being tested.

24. The method of claim 23, wherein said first and second source programs conform to predetermined constraints, said predetermined constraints including syntactic, semantic, and runtime constraints.

25. The method of claim 23, wherein said first and second source programs are generated using a test generator, said test generator including two generation modes wherein one of said generation modes provides for generating said first source program and a second of said generation modes provides for generating said second source program.

26. The method of claim 23, wherein said first source program is generated using a test generator and said second source program is generated by using a third machine executable which transforms said first source program to said second source program.

27. A method executed in a computer system for testing machine executable programs, the method comprising the steps of:

generating a test program conforming to a predetermined runtime constraint included in a standard, said standard specifying how a machine executable produced using said test program behaves if said testprogram conforms to constraints included in the standard and when said test program is processed by a language processor generating a processor output used to produce said machine executable;

producing, using said test program and a first language processor, a first corresponding machine executable;

producing, using said first corresponding machine executable, a first output;

producing, using said test program and a second language processor, a second corresponding machine executable;

producing, using said second corresponding machine executable, a second output;

determining if there is a difference between said first and said second outputs; and

detecting a test failure if there is a difference between said first and second outputs, said test failure indicating that one of said first or second language processors does not process said test program such that a machine executable, produced using a processor output generated by one of said first or said second language processors, behaves in accordance with said standard.

28. The method of claim 27 further including the step of:

examining said first and second outputs and said first and second machine executables to determine an action to take in response to detecting said test failure.

29. The method of claim 27 wherein said test program is generated using a test generator, said test generator using a grammar to generate said test program, said grammar comprising a set of one or more grammar rules, each of said grammar rule including symbols used in said grammar rules, said symbols including nonterminals and terminals, said step of generating said test program including the steps of:

selecting a grammar rule corresponding to a nonterminal;

replacing said nonterminal with terminals and nonterminals in accordance with said grammar rule selected; and

dynamically adjusting a probability associated with a corresponding grammar rule to minimize generating a non-conforming test program, said probability affecting the frequency with which said corresponding grammar rule is selected, said non-conforming test program failing to conform to said runtime constraint.

30. The method of claim 27 wherein said step of generating said test program is performed a plurality of times each generating a new test program, said generating step being performed in said computer system while performing another of said method steps.