|Publication number||US7296188 B2|
|Application number||US 10/290,353|
|Publication date||Nov 13, 2007|
|Filing date||Nov 7, 2002|
|Priority date||Jul 11, 2002|
|Also published as||CA2393043A1, US20040010735|
|Publication number||10290353, 290353, US 7296188 B2, US 7296188B2, US-B2-7296188, US7296188 B2, US7296188B2|
|Inventors||Luiz Marcelo Aucelio Paternostro, Marius Slavescu|
|Original Assignee||International Business Machines Corporation|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (18), Referenced by (29), Classifications (7), Legal Events (8)|
|External Links: USPTO, USPTO Assignment, Espacenet|
The present invention is directed to computer application testing and, more particularly, to deriving formal test case definitions.
Most computer applications (hereinafter “applications”) are very complex systems that, due to their complexity, require significant testing to ensure that the application will execute as desired.
To facilitate the testing of applications, test cases or test suites (essentially a collection of test cases) are designed, implemented and used to test a portion or the whole of an application (often referred to as the subject under test). In many applications, these test cases manipulate the external facade or interface of the subject under test. The results of these test cases are then analyzed and evaluated. As many applications are quite complex, several, sometimes hundreds, of test cases are used for the testing of a single application. A “test case” is used herein to describe the type, subject under test and items to be tested. A test case is implemented (in a scripting or programming language) to create a “test script”.
For example, a database application may need to be tested to determine whether data can be added to the database (this is the test case). A test script would need to be created to implement the test case. The exemplary test script could include several steps, instructions or processes to test this aspect of the application may include: gaining access to update the database, transmitting the update request; receiving confirmation that the update request has been executed; reading from the database to determine if the data in the update request was stored successfully; and then logging off from the database.
As a result of execution, a test script execution will generate an output which indicates whether the application successfully or unsuccessfully performed the test case (the test output).
Modern testing tools and frameworks have been developed so that test cases and test scripts can be created, modified and managed. Test cases and test scripts are designed to improve the quality of the subject under test (e.g., reduce the number of bugs; eliminate or reduce the potential for catastrophic failure—“crashing”; improve failure recovery; etc.). Unfortunately, for many software applications, application quality has often been overshadowed by the desire to provide more and richer features. However, as the reliance on software applications increases and software is used in many more critical situations where lack of software application quality is simply not acceptable, reliability and quality has become far more important. For example, one methodology that is being promoted in the application development community is known as “Extreme Programming”. Extreme programming is a software development methodology that is based on values of simplicity, communication and feedback. One of the core principles recommends that the test cases and scripts be created before the actual software application (which will be tested by the test scripts) is created. This extreme programming methodology results (as does other methodologies) in the creation of large numbers of tests cases.
In the case where the software application is created using object oriented programming, there are often several test cases and scripts developed for a single object. A single software application may involve thousands or tens of thousands (or more) objects. As a result of both of these factors (improved focus on software application and new programming methodologies), the test case base (i.e., the collection of test cases and scripts for an application) becomes very large and complex. As a result of the size and complexity of the test case base, the logistics of managing the test cases and the scripts which implement these test cases becomes very onerous to the development team. For example, it may be difficult to ascertain whether: a script exists which corresponds to a test case; to which part of the application a test case or test script pertains; etc. Also, developers are often under pressure to use test cases and scripts to test components and system level testing using cases and scripts designed for other scenarios. This type of misapplication of test cases and scripts often results in portions of the application (e.g., components) being only partially tested. Further, as developers and test team members develop test cases and scripts either completely manually or using a combination of test tools which automate the generation of test scripts together with manual modifications or extensions, test scripts and cases developed by different people often have very different structures and quality. Finally, while new methodologies may be developed to address some of these shortcomings involving test cases and scripts, such methodologies would not address the shortcomings which exist in test cases and scripts which already exist.
Accordingly, addressing, at least in part, the shortcomings noted above, thus improving the testing of computer applications, is desired.
The present invention is directed to deriving formal test case definitions from a test script.
A model of a test case is created which is used to formally define the various portions of a test case and the test script which implements the test case. In one aspect, the invention processes an existing test script to identify the components in the test script which correspond to the portions defined in a model of a test case. These identified portions are then used to create a test script which corresponds to the structure of the test model.
The model created may be compliant with testing models promulgated by standards or quasi-standard groups. The model is a high level description of a test script and hides the implementation details which are usually irrelevant to the test case design, test case management and test analysis (e.g., whether there is sufficient test case coverage for a particular feature of a software application). Moreover, once a test script has been processed such that the underlying test case (or portions thereof) has been “mapped” to the test case model, analysis of whether the test case effectively tests or addresses the requirements for the subject under test is made simpler for developers. This enables the developers to more effectively use their time and energy (rather than spend it on test case management). Furthermore, ensuring that test cases are mapped to a clear and understandable model enables test cases to be more easily understood thus allowing for more test cases to be reused or adapted to other areas.
Additionally, embodiments of the invention enable the creation of test scripts, in one or more languages, from a test case which conforms to the model. As will be appreciated, the model employed could be modified or altered to provide additional advantages such as enabling extensions of the model to be created.
In accordance with an aspect of the present invention there is provided a method of creating a test script comprising: mapping at least a portion of received input data to an exemplary model of a test script; generating a test script using said mapped portion of said received input data, said test script conforming to said exemplary model.
In accordance with another aspect of the present invention there is provided a computer readable media storing data and instructions, said data and instructions when executed by a computer system adapt said computer system to: map at least a portion of received input data to an exemplary model of a test script; generate a test script using said mapped portion of said received input data, said test script conforming to said exemplary model.
In accordance with still another aspect of the present invention there is provided a method of creating a test script comprising: means for mapping at least a portion of received input data to an exemplary model of a test script; means for generating a test script using said mapped portion of said received input data, said test script conforming to said exemplary model.
In accordance with still another aspect of the present invention there is provided a conforming test script conforming to an exemplary model of a test script, said conforming test script generated by: mapping at least a portion of a received non-conforming test script to said exemplary model of a test script; generating said test script using said mapped portions of said received input data.
Other aspects and features of the present invention will become apparent to those ordinarily skilled in the art upon review of the following description of specific embodiments of the invention in conjunction with the accompanying figures.
In the figures which illustrate an example embodiment of this invention:
An embodiment of the invention, computer system 100, is illustrated in
Throughout the description herein, an embodiment of the invention is illustrated with aspects of the invention embodied solely on computer system 100. As will be appreciated by those of ordinary skill in the art, aspects of the invention may be distributed amongst one or more networked computing devices which interact with computer system 100 via one or more data networks such as, for example, network 108. However, for ease of understanding, aspects of the invention have been embodied in a single computing device—computer system 100.
Computer system 100 includes processing system 102 which communicates with various input devices 104, output devices 106 and network 108. Input devices 104, two of which are shown, may include, for example, a keyboard, a mouse, a scanner, an imaging system (e.g., a camera, etc.) or the like. Similarly, output devices 106 (only one of which is illustrated) may include displays, information display unit printers and the like. Additionally, combination input/output (I/O) devices may also be in communication with processing system 102. Examples of conventional I/O devices include removable and fixed recordable media (e.g., floppy disk drives, tape drives, CD-ROM drives, DVD-RW drives, etc.), touch screen displays and the like.
Exemplary processing system 102 is illustrated in greater detail in
CPU 202 is a processing unit, such as an Intel Pentium™, IBM PowerPC™, Sun Microsystems UltraSparc™ processor or the like, suitable for the operations described herein. As will be appreciated by those of ordinary skill in the art, other embodiments of processing system 102 could use alternative CPUs and may include embodiments in which one or more CPUs are employed. CPU 202 may include various support circuits to enable communication between itself and the other components of processing system 102.
Memory 204 includes both volatile and persistent memory for the storage of: operational instructions for execution by CPU 202, data registers, application storage and the like. Memory 204 preferably includes a combination of random access memory (RAM), read only memory (ROM) and persistent memory such as that provided by a hard disk drive.
Network I/F 208 enables communication between computer system 100 and other network computing devices (not shown) via network 108. Network I/F 208 may be embodied in one or more conventional communication devices. Examples of a conventional communication device include an Ethernet card, a token ring card, a modem or the like. Network I/F 208 may also enable the retrieval or transmission of instructions for execution by CPU 202 from or to a remote storage media or device via network 108.
I/O I/F 210 enables communication between processing system 102 and the various I/O devices 104, 106. I/O I/F 210 may include, for example, a video card for interfacing with an external display such as output device 106. Additionally, I/O I/F 210 may enable communication between processing system 102 and a removable media 212. Although removable media 212 is illustrated as a conventional diskette other removable memory devices such as Zip™ drives, flash cards, CD-ROMs, static memory devices and the like may also be employed. Removable media 212 may be used to provide instructions for execution by CPU 202 or as a removable data storage device.
The computer instructions/applications stored in memory 204 and executed by CPU 202 (thus adapting the operation of computer system 100 as described herein) are illustrated in functional block form in
As illustrated, for exemplary purposes only, memory 204 stores operating system (OS) 302, communications suite 304, test tool 306, existing test script(s) 308, model 310, conforming test script(s) 312 and the application (or portion thereof) under test 314 (hereinafter “application 314”).
OS 302 is an operating system suitable for operation with a selected CPU 202 and the operations described herein. Multitasking, multithreaded operating systems such as, for example, IBM AIX™, Microsoft Windows NT™, Linux and the like, are expected in many embodiments to be preferred.
Communication suite 304 provides, through, interaction with OS 302 and network I/F 208 (
Test tool 306 is used by testers and developers to generate test scripts 312 which, when executed, test aspects of application 314. Conforming test scripts 312 conform to the model 310 (described below in greater detail with reference to
An existing test script 308 is typically a test script that was not created using test tool 306. In most cases, an existing test script 308 was coded manually by a developer/tester. That is, in most instances an existing test script 308 is a conventional test script known to those of ordinary skill in the art. In the exemplary embodiment described herein existing test scripts 308 are JUnit test scripts (available from the JUnit.org web site). That is, the test scripts in the exemplary embodiment use the JUnit.org framework and runners. The runners provided by the JUnit.org framework allow for both text and graphical based execution, monitoring and analysis of the executing and executed test scripts.
Test model 310 (hereinafter “model 310”) models the organization of a test case and its corresponding test script. That is, the general layout, structure and data contained in a test case and test script is abstracted to a generic model which is then used to create additional test cases and test scripts. In the exemplary embodiment, the model 310 is graphically illustrated using the Unified Modeling Language (UML) from the Object Management Group, Inc. of Needham, Mass., USA (maintaining a web site at www.omg.org). Object Management Group, Inc. is an open membership, not-for-profit consortium that produces and maintains computer industry specifications for interoperable enterprise applications. The UML specification, version 1.4, the contents of which are hereby incorporated herein by reference, is available at http://cgi.omg.org/docs/formal/01-09-67.pdf. The contents of the exemplary model, illustrated using UML, is described in greater detail below with reference to
Model 310 is used by test tool 306 to identify information in an existing test script 308 which is included in model 310. The information identified by test 306 from an existing test script 308 is then structured and organized into a conforming test script 312 which conforms (i.e., complies with, follows, etc.) to model 310. Similarly, test tool 306 also uses model 310 to create conforming test scripts 312 which are not based on an existing test script 308 but are developed to implement a new test case.
Conforming test scripts 312 are test scripts which conform to model 310. That is, the structure, organization and data contained in a conforming test script 312 conforms to the model 310.
Conforming test scripts 312 in the exemplary embodiment are implemented in Java and use the JUnit.org runners for execution. Accordingly, conforming test scripts 312, in the exemplary embodiment, are similar to existing test scripts 308 in that both are coded in Java and both use the JUnit.org runners. A difference, however, is that the conforming test scripts 312 conform to model 310 whereas existing test scripts 308 do not conform to model 310. It is to be noted that while the coding languages and runners used by both existing and conforming test scripts 308, 312, respectively, are the same in the exemplary embodiment, alternative embodiments do not require such similarity. Existing and conforming test scripts 308, 312 could use different languages, different execution runners and the like. It is to be further noted, that while test tool 306 can be employed to create a conforming test script 312 which conforms to model 310 using an existing test script 308, test tool 306 can also generate a test script 312 which conforms to model 310 based on user input that is not based on an existing test script 308.
An exemplary test script 308, 312 using Java that can be executed using the JUnit.org runner is illustrated in
As described above, application under test 314 is an application (or portion thereof—e.g., a class, a component, etc.) which is tested by executing a test script 308 or 312 using a runner (or test tool 306 if, as in the exemplary embodiment, test tool 306 includes a runner).
The interaction and relationship between existing test scripts 308, model 310 and generated or conforming test scripts 312 illustrating one aspect of the present invention is shown in
Using model 310, test tool 306 processes an input test script 308 to generate a conforming test script 312. That is, test tool 306 will identify relevant information contained within an existing test script 308 and populate (fully or partially) a new test script using this identified relevant information that conforms with model 310 (thus, creating a conforming test script 312). Alternatively, test tool 306 can generate a conforming test script 312 from user input 404 using model 310. That is, user input 404 received by test tool 306 is used to populate a test script 312 that conforms to the structure and organization of model 310.
To better understand the embodiments of the invention described herein, an exemplary model 310 (using UML graphical notations) is illustrated in
Each instantiation of abstract class TaskDefinition 502 is associated with only one TaskDefinitionAssociation 508. In the exemplary embodiment, TaskDefinitionAssociation class 508 is a helper class which provides a flexible way to link tasks with blocks.
Class TestcaseDefinition 504 and abstract class TestcaseDefinitionChild 506 are extensions of abstract class TaskDefinition 502. For each object instantiated from Definition class 504, one or more child tasks based on the TestcaseDefinitionChild abstract class 506 can be created.
As is known by those of ordinary skill in the art familiar with UML, the “by value” notation (identified by a solid diamond—see, for example, the relationship between TestcaseDefinition class 504 and TestDefinitionChild 506) and the “by reference” notation (identified by the diamond outline—see for example, the relationship between TaskDefintion 502 and TaskDefinitionAssociation 508) is specific to the particular embodiment. The “by value” notation indicates that the elements of a collection are dependent upon the container associated with those elements. In many embodiments, the “by value” notation suggests that the elements are serialized in the same file as the associated container. The “by reference” notation, in contrast, usually indicates that the related elements are serialized in different files.
Each object instantiated from a TestcaseDefinition class 504 is associated with one object instantiated from the BlockDefinition class 510. The BlockDefinition class 510 includes one attribute, flow, having the type FlowType. In the exemplary embodiment the FlowType defines the execution flow mechanism of the tasks at the block level. For example, the described embodiment provides for: “sequential” flows—i.e., tasks performed one after another; —“asynchronous”—i.e., tasks performed in parallel—or any other flow type a task scheduler may support.
Extensions of the abstract class TestcaseDefinitionChild abstract class 506 are the BlockDefinition class 510 and abstract classes PrimitiveTaskDefinition 512 and VerificationPointDefinition 518. The PrimitiveTaskDefinition abstract class 512 is extended by JavaTaskDefinition class 514. In turn, each object instantiated from JavaTaskDefinition class 514 is associated with a single object instantiated from JavaSetUpTaskDefinition class 522 and a single object instantiated from JavaCleanUpTaskDefinition class 524.
The various classes and their associated purpose in the exemplary embodiment which are illustrated in
the model 310 representation of
the definition of a test case. This
class provides common attributes,
association and behaviour for dif-
ferent types of test cases. Basically
the content of a TestcaseDefinition
is a set tasks, verification points
and other test cases organized in
is the container of the tasks of a
test case definition. This class pro-
vides some runtime behaviours
such as execution flow (sequence
or parallel execution).
is a particular type of task that al-
lows the invocation of a particular
method declared on any Java class
or the execution of a code snippet
the base class for all the elements
that are used in a test case (the test
case itself extends a
the base class for any element that
will never have any child within a
test case structure. In a another
words, they are the leaf elements.
base class for all the elements that
perform a specific task on the
subject under test while the test
case is executed. A specific task
could be a API method invocation
which stimulates the subject
base class for all the elements that
perform an observation over how
the subject under test reacted to a
previous stimulation or that records
the current status of the .subject
is a particular type of verification
point to be used to validate the
results produced by a Java task.
is a particular type of task that
allow the set up of a block in a
Java test case.
is a particular type of task that
allows for the clean up of a block
in a Java test case.
The operations 600 of test tool 306, and interactions with model 310, test scripts 308 and 312, is illustrated by flow chart in
Operations 600 are used to identify those portions of an existing test scripts 308 received by test tool 306; map those identified portions to the portions of model 310 and output a conforming test script 312. In order to understand the mapping function, it is first necessary to highlight some elements from the JUnit.org framework and the definition model being employed. As noted above, alternative embodiments could employ a framework and runners which are different from those provided by the JUnit.org organization. For example, while the exemplary embodiment employs a runner which executes JUnit compliant test cases, alternative runners, such as the Rational RobotJ runner, available from Rational Software Corporation of Lexington, Mass., could employed in alternative embodiments.
The JUnit framework main classes and their main methods are described below in greater detail to assist in the understanding of the exemplary.
The junit.framework.TestCase class encapsulates the logic of a test case and has the following main methods:
implements the logic of a unit test. Usually exercises a
small portion of a class (although this is not requirement
in alternative embodiments). If the TestCase does not
provide a suite( ) method the framework runner will
execute all the test methods of the test case in the
sequence they were created.
executed by the framework runner before each test
executed by the framework runner after each test
allows the test case developer to select which test
methods will be executed and also allows the invocation
of others test cases. Whenever a test case is executed
the framework runner will introspect the class looking for
The junit.framework.TestSuite class is used for test suites. As noted above, a test suite is essentially a collection of test cases/scripts. As such, a test suite can be composed by test methods from different test cases. The main methods are:
Adds a test method or another test suite to the suite
Adds all the test methods from a specific test script to
During a test case execution, after performing a validation (or verification point), for example, the JUnit.org framework relies on the Java exception mechanism to log any unexpected result. Developers employing the JUnit.org framework should define the tests to be applied and when to throw an exception. This is usually done by calls to the variations of “assert” provided as indicated on the last line of the method “testSimpleAdd” in
During processing (operations 604-608), test tool 306 determines whether the input file (an existing test script 308—“JUnitTestCase.java”) is a test suite or only a test case (604). This determination is performed by determining whether the existing test script extends either the TestCase type or the TestSuite type.
If test tool 306 determines that the input existing test case 308 is a test case (and not a test suite), then there still exists the possibility that the identified test case contains a test suite. Accordingly, a further determination is made by the exemplary test tool 306 to ascertain whether the identified test case contains a test suite (608, 706).
Assuming that test tool 306 has identified a test case (604) that does not contain a test suite (608), then test tool 306 creates test case definition object (614) corresponding to object 504 (
The exemplary embodiment uses Java model elements. The Java model is a model of the Java language specification implemented in Java—it covers all the elements used in a Java source file.
Of Note Are IType and IMethod, Described Briefly Below:
For an implementation reference, see the org.eclipse.jdt.core at “www.eclipse.org”.
Initially, a parser is used to load the testcases Java source code in a Java model (the internal Java class representation) and then using the algorithm presented on
The source code parser in the exemplary embodiment may be implemented through some slight modifications of a conventional Java parser. The source code parser implements the following functions (methods) illustrated in
Once the individual methods (test methods and the associated setUp and tearDown methods) have been identified (through execution of pseudo-code 730), these methods are used to populate objects corresponding to the JavaTaskDefinition, JavaSetUpTaskDefinition, and JavaCleanUpTaskDefinition classes 514, 522, and 524, respectively. Test tool 306 populates these objects by iterating through the each test method identified (610, 710).
If, instead of determining that the existing test script 308 is a test case, test tool 306 determines that the input file is a test suite (604), test tool 306 determines whether the identified test suite includes a suite method (612). If the identified test suite does not include a suite method, the test suite is invalid and an exception is thrown (620). However, if the identified test suite is valid (i.e., the test suite contains a suite method), then for each add test method, an object instantiated from JavaTaskDefinition class 514 is created or an object instantiated from BlockDefinition class 510 is created (614) as described below.
During operation 614, test tool 306 parses the test suite (712) to identify the first level of suite members. That is, test tool 306 parses the test suite to identify the first level of tasks in a test case hierarchy. The first level of tasks are those children that are the children of the top level block or the block associated with the root test case. Pseudo-code 712 indicates that test tool 306 will parse the suite method, statement by statement, and for each addTest or addTestSuite, test tool 306 will return a list of IMethod (see pseudo-code 732 in
Upon completion of the parsing of the identified test suite, test tool 306 iterates through each method identified (714). During the iteration loop 714, if a selected identified method is a test suite (716), an object corresponding to BlockDefinition class 510 is created (716) (a BlockDefinition object acts as a container of the tasks of a test case definition). Once a BlockDefinition object has been created, the test case contained in the test suite method being processed is passed to pseudo-code portion 730 to derive any non-top level test cases or test suites contained therein (720). Pseudo-code 730 is executed by test tool 306 to derive and test suites (722) or iterates through the test methods of a test case (728, 724).
If during the iteration loop 714, a selected identified method is a test case (718), then test tool 306 derives the test methods (718). As noted above, an individual test method is derived and populates the template used to create a conforming test script 312 through the execution of pseudo-code 730. Pseudo-code 730 ensures that the test method and its associated setUp and tearDown methods are identified and the data therein is used to populate objects instantiated from JavaTaskDefinition, JavaSetUpTaskDefinition, and JavaCleanUpTaskDefinition classes 514, 522, and 524, respectively, of model 310.
Referring back to
As a result of operations 600, an input existing test script 308 is processed and a conforming test script 312 is generated by test tool 306 which conforms to model 310.
As will be appreciated by those skilled in the art, modifications to the above-described embodiment can be made without departing from the essence of the invention. For example, alternative embodiments could alter the operations performed for parsing the input test scripts 308 or the test case model 310. Other embodiments and variations will also be apparent to those of ordinary skill in the art.
While one (or more) embodiment(s) of this invention has been illustrated in the accompanying drawings and described above, it will be evident to those skilled in the art that changes and modifications may be made therein without departing from the essence of this invention. All such modifications or variations are believed to be within the sphere and scope of the invention as defined by the claims appended hereto. Other modifications will be apparent to those skilled in the art and, therefore, the invention is defined in the claims.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US5021997 *||Sep 29, 1986||Jun 4, 1991||At&T Bell Laboratories||Test automation system|
|US5414836||Sep 29, 1993||May 9, 1995||International Business Machines Corporation||Software testing system that employs a graphical interface to generate test cases configured as hybrid tree structures|
|US5671351 *||Apr 13, 1995||Sep 23, 1997||Texas Instruments Incorporated||System and method for automated testing and monitoring of software applications|
|US5754755 *||Oct 10, 1996||May 19, 1998||Microsoft Corporation||Method and system for generating test scripts|
|US5778169 *||Aug 7, 1995||Jul 7, 1998||Synopsys, Inc.||Computer system having improved regression testing|
|US6031990 *||Apr 15, 1997||Feb 29, 2000||Compuware Corporation||Computer software testing management|
|US6067639 *||Nov 9, 1995||May 23, 2000||Microsoft Corporation||Method for integrating automated software testing with software development|
|US6134674 *||Dec 11, 1997||Oct 17, 2000||Sony Corporation||Computer based test operating system|
|US6148277 *||Dec 18, 1997||Nov 14, 2000||Nortel Networks Corporation||Apparatus and method for generating model reference tests|
|US6182245 *||Aug 31, 1998||Jan 30, 2001||Lsi Logic Corporation||Software test case client/server system and method|
|US6219829||Feb 8, 2000||Apr 17, 2001||Compuware Corporation||Computer software testing management|
|US7058857 *||Oct 10, 2001||Jun 6, 2006||International Business Machines Corporation||Method and system for testing a software product|
|US20010052089 *||Apr 18, 2001||Dec 13, 2001||Microsoft Corporation||Automated testing|
|US20030212924 *||May 8, 2002||Nov 13, 2003||Sun Microsystems, Inc.||Software development test case analyzer and optimizer|
|US20040015846 *||Aug 13, 2001||Jan 22, 2004||Jupiter Controller, Inc.||System, device and method for integrating functioning of autonomous processing modules, and testing apparatus using same|
|US20040088677 *||Nov 4, 2002||May 6, 2004||International Business Machines Corporation||Method and system for generating an optimized suite of test cases|
|JPH01135348A||Title not available|
|JPS6463116A||Title not available|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US7873944 *||Feb 22, 2006||Jan 18, 2011||International Business Machines Corporation||System and method for maintaining and testing a software application|
|US7913259 *||Mar 31, 2006||Mar 22, 2011||Sap Ag||Task-graph for process synchronization and control|
|US8195982 *||Jun 22, 2010||Jun 5, 2012||TestPro Pty Ltd||Systems and methods for managing testing functionalities|
|US8276122||Sep 24, 2008||Sep 25, 2012||International Business Machines Corporation||Method to speed up creation of JUnit test cases|
|US8307342||Jun 10, 2008||Nov 6, 2012||Honeywell International Inc.||Method, apparatus, and system for automatic test generation from statecharts|
|US8347147 *||Mar 9, 2009||Jan 1, 2013||Wipro Limited||Lifecycle management of automated testing|
|US8423879||Oct 8, 2008||Apr 16, 2013||Honeywell International Inc.||Method and apparatus for test generation from hybrid diagrams with combined data flow and statechart notation|
|US8458666 *||Oct 22, 2008||Jun 4, 2013||Oracle International Corporation||Methods and systems for implementing a test automation framework for testing software applications on UNIX/LINUX based machines|
|US8601436 *||Aug 10, 2010||Dec 3, 2013||Knu-Industry Cooperation Foundation||Simulation-based interface testing automation system and method for robot software components|
|US8984343||Jun 24, 2011||Mar 17, 2015||Honeywell International Inc.||Error propagation in a system model|
|US8984488||Jan 14, 2011||Mar 17, 2015||Honeywell International Inc.||Type and range propagation through data-flow models|
|US9038026 *||Oct 17, 2011||May 19, 2015||International Business Machines Corporation||System and method for automating test automation|
|US9053238 *||Jan 25, 2013||Jun 9, 2015||International Business Machines Corporation||Tool-independent automated testing of software|
|US9098619||Nov 18, 2010||Aug 4, 2015||Honeywell International Inc.||Method for automated error detection and verification of software|
|US20070234367 *||Mar 31, 2006||Oct 4, 2007||Gunter Schmitt||Task-graph for process synchronization and control|
|US20070240116 *||Feb 22, 2006||Oct 11, 2007||International Business Machines Corporation||System and method for maintaining and testing a software application|
|US20090287958 *||Oct 8, 2008||Nov 19, 2009||Honeywell International Inc.||Method and apparatus for test generation from hybrid diagrams with combined data flow and statechart notation|
|US20090287963 *||Jun 10, 2008||Nov 19, 2009||Honeywell International, Inc||Method, Apparatus, And System For Automatic Test Generation From Statecharts|
|US20100077381 *||Sep 24, 2008||Mar 25, 2010||International Business Machines Corporation||Method to speed Up Creation of JUnit Test Cases|
|US20100100872 *||Oct 22, 2008||Apr 22, 2010||Oracle International Corporation||Methods and systems for implementing a test automation framework for testing software applications on unix/linux based machines|
|US20100192128 *||Jan 27, 2009||Jul 29, 2010||Honeywell International Inc.||System and methods of using test points and signal overrides in requirements-based test generation|
|US20100229155 *||Mar 9, 2009||Sep 9, 2010||Pandiyan Adiyapatham||Lifecycle management of automated testing|
|US20100235816 *||Mar 16, 2009||Sep 16, 2010||Ibm Corporation||Data-driven testing without data configuration|
|US20100299561 *||Jun 22, 2010||Nov 25, 2010||Scott Ian Marchant||Systems and methods for managing testing functionalities|
|US20100333073 *||Jun 29, 2009||Dec 30, 2010||Honeywell International Inc.||Systems and methods for automated generation of software tests based on modeling the software test domain|
|US20110307860 *||Aug 10, 2010||Dec 15, 2011||Hong Seong Park||Simulation-based interface testing automation system and method for robot software components|
|US20130097586 *||Oct 17, 2011||Apr 18, 2013||International Business Machines Corporation||System and Method For Automating Test Automation|
|US20130104105 *||Apr 13, 2012||Apr 25, 2013||Julian M. Brown||Test data supply chain manager for an integrated testing platform|
|US20140215439 *||Jan 25, 2013||Jul 31, 2014||International Business Machines Corporation||Tool-independent automated testing of software|
|U.S. Classification||714/38.14, 714/E11.208, 717/124|
|International Classification||G06F11/36, G06F11/00|
|Nov 7, 2002||AS||Assignment|
Owner name: INTERNATIONAL BUSINESS MACHINES CORPORATION, NEW Y
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:PATERNOSTRO, LUIZ MARCELO AUCELIO;SLAVESCU, MARIUS;REEL/FRAME:013477/0205
Effective date: 20021025
|Jun 20, 2011||REMI||Maintenance fee reminder mailed|
|Sep 13, 2011||AS||Assignment|
Owner name: GOOGLE INC., CALIFORNIA
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:INTERNATIONAL BUSINESS MACHINES CORPORATION;REEL/FRAME:026894/0001
Effective date: 20110817
|Sep 20, 2011||SULP||Surcharge for late payment|
|Sep 20, 2011||FPAY||Fee payment|
Year of fee payment: 4
|Jun 26, 2015||REMI||Maintenance fee reminder mailed|
|Nov 13, 2015||LAPS||Lapse for failure to pay maintenance fees|
|Jan 5, 2016||FP||Expired due to failure to pay maintenance fee|
Effective date: 20151113