METHOD AND SYSTEM FOR TESTING COMPLEX MACHINE CONTROL SOFTWARE

• US 20110145653A1
• Filed: 08/14/2009
• Published: 06/16/2011
• Est. Priority Date: 08/15/2008
• Status: Abandoned Application

• Current Assignee: Verum Holding BV
• Original Assignee: Verum Holding BV
• Inventors: Bouwmeester, Leon, Broadfoot, Guy, Posta, Ladislau, Langen, Jos, Hopcroft, Philippa
• Application Number:
  US13/058,292
• Publication Number:
  US 20110145653A1
• Time in Patent Office: Days
• US Class Current: 714/38.1
• CPC Class Codes: G06F 11/3604 Software analysis for verifying properties of programs byte-code verification G06F9/44589
• CPC Class Codes: G06F 11/3688 for test execution, e.g. scheduling of test suites

Abstract

A method and system for testing complex machine control software A method of formally testing a complex machine control software program in order to determine defects within the software program is described. The software program to be tested (SUT) has a defined test boundary, encompassing the complete set of visible behaviour of the SUT, and at least one interface between the SUT and an external component, the at least one interface being defined in a formal, mathematically verified interface specification. The method comprises: obtaining a usage model for specifying the externally visible behaviour of the SUT as a plurality of usage scenarios, on the basis of the verified interface specification; verifying the usage model, using a usage model verifier, to generate a verified usage model of the total set of observable, expected behaviour of a compliant SUT with respect to its interfaces; extracting, using a sequence extractor, a plurality of test sequences from the verified usage model; executing, using a test execution means, a plurality of test cases corresponding to the plurality of test sequences; monitoring the externally visible behaviour of the SUT as the plurality of test sequences are executed; and comparing the monitored externally visible behaviour with an expected behaviour of the SUT.

Claims

1-39. -39. (canceled)

40. A computer-implemented method of formally testing a complex machine control software program in order to determine defects within the software program, wherein the software program to be tested (SUT) has a defined test boundary, encompassing the complete set of visible behaviour of the SUT, and at least one interface between the SUT and an external component, the at least one interface being defined in a formal, mathematically verified interface specification, the method comprising:

obtaining a usage model for specifying the externally visible behaviour of the SUT as a plurality of usage scenarios, on the basis of the verified interface specification;

verifying the usage model, using a usage model verifier, to generate a verified usage model of the total set of observable, required behaviour of a compliant SUT with respect to its interfaces;

extracting, using a sequence extractor, a plurality of test sequences from the verified usage model;

executing, using a test executor, a plurality of test cases corresponding to the plurality of test sequences;

monitoring the externally visible behaviour of the SUT as the plurality of test sequences are executed; and

comparing the monitored externally visible behaviour with an expected behaviour of the SUT.

41. The computer-implemented method as claimed in claim 40, wherein the SUT has a plurality of interfaces for enabling communication to and from a plurality of external components, the plurality of interfaces being specified formally as sequence-based specifications.

42. The computer-implemented method as claimed in claim 40, wherein the obtaining step comprises obtaining a usage model which specifies the usage model in sequence based specification (SBS) notation within enumeration tables, each row of a table identifying one stimulus, its response and its equivalence for a particular usage scenario.

43. The computer-implemented method as claimed in claim 42, wherein the obtaining step comprises obtaining a usage model in which the SBS notation has been extended, in the enumeration tables, to include one or more probability columns to enable the usage model to represent multiple usage scenarios.

44. The computer-implemented method as claimed in claim 42, wherein the SBS notation has been extended, in the enumeration tables, to specify a label definition, such that when a particular usage scenario in the usage table results in non-deterministic behaviour, each label definition has a particular action associated therewith to resolve the non-deterministic behaviour.

45. The computer-implemented method as claimed in claim 44, wherein the SBS notation has been extended, in the enumeration tables, to specify a label reference, such that when a particular usage scenario in the usage table results in non-deterministic behaviour, each label reference has a corresponding label definition within the enumeration table for resolving the non-deterministic behaviour.

46. The computer-implemented method as claimed claim 42, wherein the obtaining step further comprises obtaining a usage model which specifies an ignore set of allowable responses to identify events which may be ignored during execution of the test cases, depending on a current state in the usage model.

47. The computer-implemented method of claim 42, wherein the obtaining step comprises providing a usage model editor to enable the creation of the usage model.

48. The computer-implemented method as claimed in claim 40, wherein verifying step comprises:

generating a corresponding mathematical model from the usage model and the plurality of formalised interface specifications; and

testing whether the mathematical model is complete and correct.

49. The computer-implemented method as claimed in claim 48, wherein the testing step comprises checking the mathematical model against a plurality of well-formedness rules which are implemented through a model checker.

50. The computer-implemented method as claimed in claim 40, further comprising translating the usage model into a Markov model representation which is free of history and predicate information such that in any given present state, all future and past states are independent of the present state.

51. The computer-implemented method as claimed in claim 50, wherein the extracting step uses Graph Theory for extracting the set of test sequences.

52. The computer-implemented method as claimed in claim 50, wherein the extracting step further comprises extracting a minimal coverage test set of test sequences which specify paths through the usage model, the paths visiting every node and causing execution of every transition in the usage model.

53. The computer-implemented method as claimed in claim 52, wherein the executing step comprises executing a plurality of test cases which correspond to the minimal coverage test set of test sequences and the comparing step comprises comparing the monitored externally visible behaviour of the SUT to the expected behaviour of the SUT for full coverage of all transitions in the usage model.

54. The computer-implemented method as claimed in claim 43, wherein the extracting step uses Graph Theory for extracting the set of test sequences and further comprises extracting a random test set of test sequences, the selection of the random test set of test sequences being weighted in dependence on specified probabilities of the usage scenarios occurring during operation.

55. The computer-implemented method as claimed claim 54, wherein the executing step further comprises executing the random test set and the comparing step comprises comparing the monitored externally visible behaviour of the SUT to the expected behaviour of the SUT.

56. The computer-implemented method as claimed in claim 54, wherein each usage scenario is attributed with a plurality of probabilities depending on different operating conditions to be tested.

57. The computer-implemented method as claimed in claim 55, wherein the random test set is sufficiently large in order to provide a statistically significant measure of the reliability of the SUT, the size of the random test set being determined as a function of a user-specified reliability and confidence level.

58. The computer-implemented method as claimed in claim 40, further comprising converting the extracted set of test sequences into a set of executable test cases in an automatically executable language.

59. The computer-implemented method as claimed in claim 58, wherein the automatically executable language is a programming language or an interpretable scripting language.

60. The computer-implemented method as claimed in claim 59, wherein the interpretable scripting language is selected from Perl or Python.

61. The computer-implemented method as claimed in claim 41, wherein the executing step comprises routing the plurality of test cases through a test router, the test router being arranged to route call instructions from the plurality of test cases to a corresponding one of the plurality of interfaces of the SUT.

62. The computer-implemented method as claimed in claim 61, further comprising generating the test router automatically on the basis of the formal interface specifications for the plurality of interfaces to the SUT which cross the defined test boundary.

63. The computer-implemented method as claimed in claim 61, further comprising specifying the test router formally as a sequence based specification, which is verified for completeness and correctness.

64. The computer-implemented method as claimed in claim 40, further comprising developing a plurality of adapter components to emulate the behaviour of a corresponding external component which the SUT communicates with, wherein the adapter components are specified formally as sequence based specifications, which are verified for completeness and correctness.

65. The computer-implemented method as claimed in claim 40, wherein the test boundary is defined as being the boundary at which the test sequences are generated and at which test sequences are executed, and the method further comprises establishing the test boundary at an output side of a queue which decouples call-back responses from the external components to the SUT.

66. The computer-implemented method as claimed in claim 40, wherein the test boundary is defined as being the boundary at which the test sequences are generated and at which test sequences are executed, and the method further comprises establishing the test boundary at an input side of a queue which decouples call-back responses from the external components to the SUT.

67. The computer-implemented method as claimed in claim 40, wherein the test boundary when defined as a test boundary where the tests are generated, and when defined as a test and measurement boundary where the test sequences are executed, are located at different positions with respect to the SUT, and the method further comprises monitoring signal events which indicate when the SUT removes events from a queue which decouples call-back responses from the external components to the SUT, in order to synchronise test case execution, and using the removed events to reconcile the difference between the test boundary and the test and measurement boundary to ensure that these boundaries are matched.

68. The computer-implemented method as claimed in claim 40, further comprising generating, from the verified usage model and a plurality of used interface specifications, a tree walker graph in which paths through the graph describe every possible allowable sequence of events between the SUT and its environment, wherein a used interface is an interface between the SUT and its environment.

69. The computer-implemented method as claimed in claim 68, wherein the comparing step comprises considering events in the test sequence, traversing the tree walker graph in response to events received in response to execution of the test sequence, and distinguishing between ignorable events arriving at allowable moments which can be discarded, required events arriving at expected moments and which cause the test execution to proceed, and events that are sent by the SUT when they are not allowed according to the tree walker graph of the interface, which represent noncompliant behaviour.

70. The computer-implemented method as claimed claim 69, further comprising receiving an out of sequence event from the SUT that is defined in the tree walker graph as allowable and storing the out of sequence event in a buffer.

71. The computer-implemented method as claimed claim 70, further comprising checking the buffer each time the test sequence requires an event from the SUT, to ascertain whether the event has already arrived out of sequence, and when an event has arrived out of sequence, removing that event from the buffer as though the event has just been sent, and proceeding with the test sequence.

72. The computer-implemented method as claimed in claim 40, wherein the executing step comprises further comprises receiving valid and invalid test data sets, and using a data handler to ensure that test scenarios and subsequent executable test cases operate on realistic data during test execution.

73. The computer-implemented method as claimed in claim 72, wherein the executable test cases comprise a plurality of test steps, and the method further comprises

logging all the test steps of all the test cases in log reports in order to provide traceable results regarding the compliance of the SUT.

74. The computer-implemented method as claimed in claim 73, further comprising:

collating the data from the log reports of all the test cases from a random test set;

and generating a test report from the collated data.

75. The computer-implemented method as claimed in claim 74, further comprising:

accumulating statistical data from the test report; and

calculating a software reliability measure for the SUT.

76. The computer-implemented method as claimed in claim 40, wherein the comparing step further comprises:

determining when the testing method may end by comparing a calculated software reliability measure against a required reliability and confidence level.

77. A computer system for formally testing a complex machine control software program in order to determine defects within the software program, wherein the software program to be tested (SUT) has a defined test boundary, encompassing the complete set of visible behaviour of the SUT, and at least one interface between the SUT and an external component, the at least one interface being defined in a formal, mathematically verified interface specification, the computer system comprising:

a usage model specifying the externally visible behaviour of the SUT as a plurality of usage scenarios, on the basis of the verified interface specification;

a usage model verifier for verifying the usage model to generate a verified usage model of the total set of observable, required behaviour of a compliant SUT with respect to its interfaces;

a sequence extractor for extracting a plurality of test sequences from the verified usage model;

a test executor for executing a plurality of test cases corresponding to the plurality of test sequences;

a test monitor for monitoring the externally visible behaviour of the SUT as the plurality of test sequences are executed; and

a test analyser for comparing the monitored externally visible behaviour with an expected behaviour of the SUT.

78. A computer system for automatically generating a series of test cases for use in formally testing a complex machine control software program in order to determine defects within the software program, wherein the software program to be tested (SUT) has a defined test boundary, encompassing the complete set of visible behaviour of the SUT, and at least one interface between the SUT and an external component, the at least one interface being defined in a formal, mathematically verified interface specification, the computer system comprising:

a usage model specifying the externally visible behaviour of the SUT as a plurality of usage scenarios, on the basis of the verified interface specification;

a usage model verifier for verifying the usage model to generate a verified usage model of the total set of observable, expected behaviour of a compliant SUT with respect to its interfaces;

a Markov model generator for generating a Markov model of the verified usage model;

a sequence extractor for extracting a plurality of test sequences from the verified usage model; and

a test executor for executing a plurality of test cases on the SUT corresponding to the plurality of test sequences.

79. A computer system for formally testing a complex machine control software program in order to determine defects within the software program, wherein the software program to be tested (SUT) has a defined test boundary, encompassing the complete set of visible behaviour of the SUT, and a plurality of interfaces between the SUT and a plurality of external components for enabling communication to and from the plurality of external components, each interface being defined in a formal, mathematically verified interface specification as a sequence-based specification, the computer system comprising:

a usage model specifying the externally visible behaviour of the SUT as a plurality of usage scenarios, on the basis of the verified interface specification, the usage model specifying the usage model in sequence based specification (SBS) notation within enumeration tables, each row of a table identifying one stimulus, its response and its equivalence for a particular usage scenario;

wherein the SBS notation in the enumeration tables specifies a label definition, such that when a particular usage scenario in the usage table results in non-deterministic behaviour, each label definition has a particular action associated therewith to resolve the non-deterministic behaviour;

a usage model verifier for verifying the usage model to generate a verified usage model of the total set of observable, required behaviour of a compliant SUT with respect to its interfaces;

a sequence extractor for extracting a plurality of test sequences from the verified usage model;

a test executor for executing a plurality of test cases corresponding to the plurality of test sequences;

a test monitor for monitoring the externally visible behaviour of the SUT as the plurality of test sequences are executed;

a test analyser for comparing the monitored externally visible behaviour with an expected behaviour of the SUT.

80. The computer system as claimed in claim 79, further comprising a tree walker graph generator, arranged to use the verified usage model and a plurality of used interface specifications to generate a tree walker graph in which paths through the graph describe every possible allowable sequence of events between the SUT and its environment, wherein a used interface is an interface between the SUT and its environment.

81. A computer-implemented method of formally testing a complex machine control software program in order to determine defects within the software program, wherein the software program to be tested (SUT) has a defined test boundary, encompassing the complete set of visible behaviour of the SUT, and at least one interface between the SUT and an external component, the at least one interface being defined in a formal, mathematically verified interface specification, the computer-implemented method comprising:

obtaining a usage model for specifying the externally visible behaviour of the SUT as a plurality of usage scenarios, on the basis of the verified interface specification;

translating the usage model into a Markov model representation which is free of history and predicate information such that in any given present state, all future and past states are independent of the present state;

verifying the usage model, using a usage model verifier, to generate a verified usage model of the total set of observable, required behaviour of a compliant SUT with respect to its interfaces;

extracting, using a sequence extractor, a plurality of test sequences from the verified usage model, the extracting step using Graph Theory for extracting the set of test sequences and the further comprising extracting a minimal coverage test set of test sequences which specify paths through the usage model, the paths visiting every node and causing execution of every transition in the usage model;

executing, using a test executor, a plurality of test cases corresponding to the plurality of test sequences;

monitoring the externally visible behaviour of the SUT as the plurality of test sequences are executed; and

comparing the monitored externally visible behaviour with an expected behaviour of the SUT.