# Patent

## Title
Model-based testing of an application program under test

## Abstract

A software testing system includes a test interface and a verification interface. The test interface receives a first processing request for the application program under test. The test interface generates a second processing request equivalent to the first processing request, and communicates the first and second processing requests to the application program under test and a model of the application program, respectively. A verification interface compares a first and a second response data set received, respectively, from the application program under test and the model. The verification interface generates an error indication if a difference is determined from the comparison of the first and second response data sets. If a difference is not determined from the comparison, then the verification interface generates a success indication. The verification interface communicates either the success or error indication to the test interface.

## Background
RELATED MATTERS
This application claims priority to European Patent Application Number 09155558.1 filed Mar. 19, 2009, which is incorporated herein in its entirety.
BACKGROUND
Part of the process of building and maintenance of software systems is the testing of the system against defined requirements. Model-based testing systems utilize an instance of a software system under test in combination with a model of the system. The model is arranged to perform in accordance with the expected behavior of the software system under test. A set of tests is provided in combination with a set of checking rules for testing the behavior of both the software system under test and its model. One problem with such model-based testing systems is that their effective use involves detailed understanding of the rules and corresponding model.
SUMMARY
Embodiments include a method that receives a first processing request for an application program under test. A second processing request for a model of the application program is generated, which is equivalent to said first processing request. The first and second requests are communicated to said application program under test and said model of the application program respectively. A first response data set from the application program under test and a second response data set from the model of the application program are received. The first and second response data sets are compared. A success indication is generated if said comparing said first and second response data sets does not identify a difference. An error indication is generated if said comparing said first and second response data sets identifies a difference between the first and second data sets.
Embodiments include a digital computer comprising a processor and a memory that embodies a software testing system. The software testing system comprises a test interface configured to be identical to a user interface of an application program under test. The test interface is operable to receive a first processing request for the application program under test. The test interface generates a second processing request equivalent to the first processing request, and communicates the first processing request to the application program under test and the second processing request to a model of the application program. The software testing system also comprises a verification interface. The verification interface compares a first response data set from the application program under test and a second response data set from the model of the application program. The verification interface generates an error indication if a difference is determined from comparison of the first response data set and the second response data set. The verification interface generates a success indication if a difference is not determined from comparison of the first response data set and the second response data set. The verification interface communicates either the success indication or the error indication to the test interface.
Embodiments include a computer program product embodied within memory comprising software code for model-based testing of an application program. The computer program product comprises executable code configured to receive a first processing request for the application program under test. The executable code is configured to generate a second processing request equivalent to the first processing request. The executable code is configured to communicate the first processing request to the application program under test and the second processing request to a model of the application program. The executable code is configured to compare a first response data set from the application program under test and a second response data set from the model of the application program. The executable code is configured to generate an error indication if a difference is determined from comparison of the first response data set and the second response data set and communicate the error indication to the test interface. The executable code is configured to generate a success indication if a difference is not determined from comparison of the first response data set and the second response data set and communicate the success indication to the test interface.



BRIEF DESCRIPTION OF THE DRAWINGS
The present embodiments may be better understood, and numerous objects, features, and advantages made apparent to those skilled in the art by referencing the accompanying drawings.
FIG. 1 is a schematic illustration of a software testing system;
FIG. 2 is a schematic illustration of functional elements of the software testing system of FIG. 1;
FIG. 3 is a table illustrating a set of checking code rules used in the software testing system of FIG. 2;
FIG. 4 is a table illustrating an exception produced in the software testing system of FIG. 2; and
FIG. 5 is a flow chart illustrating processing performed by the software testing system of FIG. 2.



DESCRIPTION OF EMBODIMENT(S)
With reference to FIG. 1, a software testing system 101 comprises a computer 102 loaded with an operating system 103. The operating system 103 provides a platform for a model based testing application program 104, which utilizes an instance of an application program under test 105 in combination with a model 106 of the application program under test. The model 106 is arranged to model the expected behavior of the application program under test 105 and also to provide an identical interface to the application program under test 105.
The test application program 104 is also arranged to provide an identical interface to the application program under test 105. Thus, the test application program 104 is arranged to accept processing requests, in the form of test scenarios 107, that comprise the expected operational user interaction with the application program under test 105. The test application program 104 is arranged to pass such processing requests to both the application program under test 105 and its model 106, analyze the response as described below and provide an indication of whether the processing request was a success or whether an error occurred. The test application program 104 indicates that the processing of a request was a success if the results received from both the application program under test 105 and its model 106 are equivalent. If the results received are different then the test application program 104 indicates that there was an error in the processing of the request by the application program under test 105.
With reference to FIG. 2, the test application program 104 comprises a test interface 201 and a verification interface 202. The verification interface 202 comprises checking code 203. The test interface 201 provides the test application program 104 a user interface that is identical to that provided by the application program under test 105, so as to enable a user to interact with the test application program 104 as if interacting directly with the application program under test 105. In addition, the test interface 201 provides facilities for observing and storing the results of the testing of the application program under test 105. In response to a processing request for the application program under test (SUT) 105 made via the test interface 201, the test interface 201 is arranged to duplicate the request and pass the original request to the application program under test (SUT) 105 and the duplicated request to the model 106. In the present embodiment, the application programs 105 and model 106 are implemented using object oriented programming techniques. Thus, the original and duplicate processing requests are passed to their respective targets in the form of respective sets of SUT and model request parameters 204, 205. As will be understood by those skilled in the art, such sets of parameters may comprise any suitable parameter types acceptable to the SUT 105 and model 106. The results of the processing of the requests 204, 205 by the SUT 105 and the model 106, respectively, are returned to the verification interface 202. The results comprise respective response data sets in the form, for example, of respective result objects 206, 207.
The verification interface 202 is arranged to compare the response data sets, in the form of the result objects 206, 207, using the checking code 203. As will be understood by those skilled in the art, checking code is generally specific to a given process or method. Therefore, since the test interface 201 comprises a plurality of such processes or methods, a corresponding plurality of subsets of checking code are correspondingly provided. With reference to FIG. 3, the checking code 203 for a given method utilizes a set of checking code rules 301 to compare features of each of the result objects 206, 207 so as to identify any differences. In the example of FIG. 3, the checking code rules 301 compare the object name, version and data content. If the checking code determines that all of the relevant attributes of the result objects 206, 207 are identical then the processing of the SUT 105 is deemed to be equivalent to the model 106 in respect of the original processing request. In response to such successful processing, the verification interface 203 is arranged to encapsulate both the result objects 206, 207 in a verification object 208 and pass this object 208 to the test interface 201. The verification object 208 is arranged to enable the test interface 201 to present the response from the SUT 105. In addition, if a further processing request is issued based on the received response, the verification object 208 preserves the state of the processing with both SUT 105 and the model 106 so as to provide the necessary continuity for such further processing requests. In addition, the verification object 208 carries sufficient data for the logging of the processing requests for a given testing scenario.
If the checking code 203 determines that one or more of the attributes of the result objects 206, 207 are different, this indicates a departure of the behavior of the SUT 105 from that of its model 106. In this case, the verification interface 202 is arranged to return an error to the test interface 201 in the form of an exception. In the present embodiment, with reference to FIG. 4, an exception is defined in an exception object 401. Each exception object 401, in common with a verification object 208, is associated with the relevant result objects. In addition, the exception object provides an indication of the property of the result objects that was identified as differing along with an indication of the value of that property that was expected. The expected property value is determined from the result object 207 received from the model 106. In the example of an exception object 401 in FIG. 4, the difference was identified in the “Property:Version” attribute of the SUT result object 206. The expected value for the “Property:Version” attribute identified from the model result object 207 was “2.2”. In response to the receipt of an exception object 401, the test interface is arranged to log the exception and the user is provided with an option to continue with further processing requests if appropriate.
The processing performed by the test application program 104 when handling a processing request will now be described further with reference to the flow chart of FIG. 5. At step 501, processing is initiated in response to the start-up of the test application program 104, the SUT 105 and model 106 are identified and processing moves to step 502. At step 502, processing awaits the input of a processing request via the test interface 201 and, once a processing request is received moves to step 503. At step 503, in accordance with the functions of the duplicated SUT interface, an appropriate SUT request 204 is created along with an equivalent model request 205 and processing moves to step 504. At step 504, the SUT and model requests 204, 205 are passed to the SUT 105 and model 106 respectively and processing moves to step 505. At step 505, the result of the processing of the requests 204, 205 represented by the SUT and model objects 204, 205 is awaited in the form of the result objects 206, 207. Once the result objects 206, 207 are received processing moves to step 506. At step 506, the result objects 206, 207 are compared by the checking code 203 in accordance with the checking code rules 301 and processing moves to step 507.
At step 507, if the result objects 206, 207 are equivalent, that is, the checking code 203 identified no significant differences, then processing moves to step 508. At step 508, the result objects 206, 207 are wrapped in a verification object 208 and processing moves to step 509. At step 509, the verification object 208, indicating the success of the processing request, is passed to the test interface 201 for processing as a normal results return. Processing then returns to step 502. At step 507, if the result objects 206, 207 comprise one or more significant differences, then processing moves to step 510. At step 510, the result objects 206, 207 are wrapped in an exception object and processing moves to step 511. At step 511, an error message, indicating the identified differences and the expected values based on the model result object 207, is inserted in the exception object and processing moves to step 512. At step 512, the exception object is logged and processing moves to step 502 and proceeds as described above.
Some processing requests received by the test interface 201 may be based on previously received result objects 206, 207 wrapped in a verification object 208. In such cases, at step 503, the appropriate result objects 206, 207 are extracted from the verification object 208 so as to form the appropriate part of the relevant set of request parameters for the SUT 105 and model 106 respectively.
In another embodiment, the test application program is provided as the working front-end for the SUT enabling the SUT to be deployed while still providing a facility for monitoring discrepancies between the SUT and the model while the SUT is operational. The test interface may be arranged to avoid notifying a normal user of any received error notifications but instead to divert such error notifications to another predetermined user such as an administrator via a duplicate or other suitable interface.
In a further embodiment, the indication of the error or discrepancy is communicated to the test interface separately from the result objects or data sets. Identifiers may be provided in the error message or the result data sets to provide cross-referencing.
In another embodiment, where whole trees or graphs of SUT and model objects are returned from the SUT and model respectively, each object within the graph is wrapped up in a verification object so as to provide a graph of verification objects returned from the test interface.
The checking rules may be devised so as to check for any set of one or more identifiable discrepancies between the output of the SUT and the model.
While the embodiments described above may be implemented using object-orientated programming techniques, embodiments may also be proved using procedural or other programming techniques. Thus the objects described above that are used for communicating data between the test interface, verification interface, SUT and model may be replaced with equivalent communications means such as appropriate data sets or messages.
It will be understood by those skilled in the art that the apparatus that embodies a part or all of the present invention may be a general purpose device having software arranged to provide a part or all of an embodiment of the invention. The device could be a single device or a group of devices and the software could be a single program or a set of programs. Furthermore, any or all of the software used to implement the invention can be communicated via any suitable transmission or storage means so that the software can be loaded onto one or more devices.
While the present invention has been illustrated by the description of the embodiments thereof, and while the embodiments have been described in considerable detail, it is not the intention of the applicant to restrict or in any way limit the scope of the appended claims to such detail. Additional advantages and modifications will readily appear to those skilled in the art. Therefore, the invention in its broader aspects is not limited to the specific details representative apparatus and method, and illustrative examples shown and described. Accordingly, departures may be made from such details without departure from the spirit or scope of applicant's general inventive concept.
Plural instances may be provided for components, operations or structures described herein as a single instance. Finally, boundaries between various components, operations and data stores are somewhat arbitrary, and particular operations are illustrated in the context of specific illustrative configurations. Other allocations of functionality are envisioned and may fall within the scope of the inventive subject matter. In general, structures and functionality presented as separate components in the exemplary configurations may be implemented as a combined structure or component. Similarly, structures and functionality presented as a single component may be implemented as separate components. These and other variations, modifications, additions, and improvements may fall within the scope of the inventive subject matter.

## Claims

1. A method comprising:
receiving a first processing request for an application program under test;
generating a second processing request for a model of the application program, wherein the second processing request is equivalent to said first processing request;
communicating said first and second requests to said application program under test and said model of the application program respectively;
receiving a first response data set from the application program under test and a second response data set from the model of the application program;
comparing said first and second response data sets;
generating a success indication if said comparing said first and second response data sets does not identify a difference, wherein said generating the success indication comprises generating a verification object that encapsulates the first and second response data sets;
generating an error indication if said comparing said first and second response data sets identifies a difference between the first and second data sets;
receiving a third processing request, which is based on the first response data set, for the application program under test;
extracting a first parameter of the first response data set from the verification object;
communicating the third processing request with the first parameter to the application program under test;
extracting a second parameter of the second response data set from the verification object;
generating fourth processing request equivalent to the third processing request; and
communicating the fourth processing request with the second parameter to the model of the application program.

2. The method of claim 1, wherein said error indication comprises data indicating an attribute of the first and second response data sets that corresponds to the difference and indicating an expected value of the attribute.

3. The method of claim 1, wherein said generating the error indication comprises generating an exception.

4. The method of claim 1, wherein said error indication references said first and second response data sets.

5. The method of claim 1, wherein said comparing said first and second response data sets comprises executing a checking code on the first and second response data sets, wherein the checking code utilizes checking code rules.

6. The method of claim 5, wherein the checking code rules indicate an object name, an object version, and data content to be compared.

7. A digital computer comprising:
processor; and
a memory that embodies a software testing system that comprises,
a test interface configured to be identical to a user interface of an application program under test, the test interface operable to,
receive a first processing request for the application program under test,
generate a second processing request equivalent to the first processing request,
communicate the first processing request to the application program under test and the second processing request to a model of the application program,
receive a third processing request, which is based on the first response data set, for the application program under test,
extract a first parameter of the first response data set from the verification object,
communicate the third processing request with the first parameter to the application program under test,
extract a second parameter of the second response data set from the verification object,
generate fourth processing request equivalent to the third processing request, and
communicate the fourth processing request with the second parameter to the model of the application program; and

a verification interface operable to,
compare a first response data set from the application program under test and a second response data set from the model of the application program,
generate an error indication if a difference is determined from comparison of the first response data set and the second response data set and communicate the error indication to the test interface,
generate a success indication if a difference is not determined from comparison of the first response data set and the second response data set and communicate the success indication to the test interface, wherein the verification interface being operable to generate the success indication comprises the verification unit being operable to generate a verification object that encapsulates the first and second response data sets.

8. The digital computer of claim 7, wherein said error indication comprises data that indicates an attribute of the first and second response data sets that corresponds to the difference and indicating an expected value of the attribute.

9. The digital computer of claim 7, wherein the verification interface being operable to generate the error indication comprises the verification unit operable to generate an exception.

10. The digital computer of claim 7, wherein said error indication references said first and second response data sets.

11. The digital computer of claim 7, wherein the verification interface being operable to compare said first and second response data sets comprises the verification interface being operable to execute a checking code on the first and second response data sets, wherein the checking code utilizes checking code rules.

12. The digital computer of claim 11 wherein the checking code rules indicate an object name, an object version, and data content to be compared.

13. A computer program product embodied within a non-transitory memory comprising software code for model-based testing of an application program, the computer program product comprising:
executable code configured to,
receive a first processing request for the application program under test,
generate a second processing request for a model of the application program, wherein the second processing request is equivalent to the first processing request,
communicate said first and second requests to said application program under test and said model of the application program respectively;
receive a first response data set from the application program under test and a second response data set from the model of the application program;
compare said first and second response data sets;
generate a success indication if said compare said first and second response data sets does not identify a difference, wherein said generate the success indication comprises a generate of a verification object that encapsulates the first and second response data sets;
generate an error indication if said compare said first and second response data sets identifies a difference between the first and second data sets;
receive a third processing request, which is based on the first response data set, for the application program under test;
extract a first parameter of the first response data set from the verification object;
communicate the third processing request with the first parameter to the application program under test;
extract a second parameter of the second response data set from the verification object;
generate fourth processing request equivalent to the third processing request; and
communicate the fourth processing request with the second parameter to the model of the application program.

14. The computer program product of claim 13, wherein said error indication comprises data that indicates an attribute of the first and second response data sets that corresponds to the difference and indicating an expected value of the attribute.

15. The computer program product of claim 13, wherein the executable code configured to compare said first and second response data sets comprises the executable code configured to execute a checking code on the first and second response data sets, wherein the checking code utilizes checking code rules.

16. The computer program product of claim 15, wherein the checking code rules indicate an object name, an object version, and data content to be compared.