|Publication number||US7272822 B1|
|Application number||US 10/246,340|
|Publication date||Sep 18, 2007|
|Filing date||Sep 17, 2002|
|Priority date||Sep 17, 2002|
|Publication number||10246340, 246340, US 7272822 B1, US 7272822B1, US-B1-7272822, US7272822 B1, US7272822B1|
|Inventors||Michael Riggins, Jeffrey Feldstein, Jeffrey Hewitt|
|Original Assignee||Cisco Technology, Inc.|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (11), Non-Patent Citations (10), Referenced by (56), Classifications (11), Legal Events (4)|
|External Links: USPTO, USPTO Assignment, Espacenet|
This disclosure includes certain information that is copyrighted by the patent owner. The patent owner has no objection to reproduction of this patent document, as it appears in the official files of the U.S. Patent & Trademark Office, but otherwise reserves all copyright in the disclosure.
The present invention generally relates to testing software. The invention relates more specifically to automatically generating software tests based on metadata that is used to control the operational behavior of a software product.
The approaches described in this section could be pursued, but are not necessarily approaches that have been previously conceived or pursued. Therefore, unless otherwise indicated herein, the approaches described in this section are not prior art to the claims in this application and are not admitted to be prior art by inclusion in this section.
Commercial software normally is subjected to testing before release to customers. In some approaches, the testing is done using automatic testing systems. In one approach, an automatic testing system is used to capture and replay a script of mouse clicks or keystrokes for the purpose of testing graphical user interface output.
Alternatively, a test engineer can prepare a custom test (“test script” herein) in a testing language, which may be a scripting language or a conventional programming language. The test scripts instruct the automatic testing system how to interact with a program under test, and how to evaluate output generated by the program under test. For example, a test script can simulate mouse clicks or keyboard interaction with a program under test, and the testing system can inform the test script whether the program under test actually has displayed a particular object on the screen. Output is generated to specify whether objects are correctly displayed or the tests are successful. Examples of commercially available testing systems that can test graphical user interfaces include Mercury Interactive WinRunner, and RobotJ from Rational Software.
However, developing test code or scripts that provide suites of automated tests for complex commercial software may involve extensive engineering time. In particular, the initial development of tests for a software product is resource-intensive, typically involving study of engineering documentation, extensive hand coding of test scripts and assembly of the scripts into test suites. When tests of application programming interfaces (APIs) are needed, extensive study of documentation and hand-written custom test programs may be needed.
After initial test development, significant ongoing effort may be needed as new features are added to a product. All such coding and development is typically manual, and there are no known industry-standard mechanisms to automatically generate test code.
Data driven software has been in use for many years throughout the software industry. In some software development approaches, metadata drives user interfaces and run-time behavior of a software program. Known Web-based network management software products use data-driven mechanisms to dynamically drive the visual representation of the user interfaces. For example, a web-based user interface development and runtime system (“Picasso”) used internally at Cisco Systems, Inc. has been used to generate XML-structured data to define web-based navigation interfaces and security characteristics for commercial software products such as CiscoWorks 2000. The Picasso system consists of a SiteMap tool, which generates general navigation and security control metadata; a Content Area tool, which assists in developing application-specific logic; and a User Interface Infrastruction (“UII”) runtime system, which interprets SiteMap and Content Area metadata files at runtime, and generates the visualization of web-based software products. The XML data defines a hierarchy of pages that are displayed as part of an application. Each page is assigned a unique identifier value and security level.
The UII runtime engine has a bookmarking function that can be used to directly display a particular page or screen of an application program, without traversing a hierarchical tree of pages, by providing a screen identifier of the page in a URL associated with the program.
Based on the foregoing, there is a clear need in this field for an improved way to automatically generate tests for a software program based on metadata relating to the program.
There is also a need for an improved way to automatically generate user interface tests for a software program based on an existing description of the user interface. It would be particularly useful to have an approach in which metadata defining a user interface is re-used for purposes of defining tests.
The present invention is illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings and in which like reference numerals refer to similar elements and in which:
A method and apparatus for generating software tests based on metadata that is used to control the operational behavior of a software product is described. In the following description, for the purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding of the present invention. It will be apparent, however, to one skilled in the art that the present invention may be practiced without these specific details. In other instances, well-known structures and devices are shown in block diagram form in order to avoid unnecessarily obscuring the present invention.
Embodiments are described herein according to the following outline:
The needs identified in the foregoing Background, and other needs and objects that will become apparent for the following description, are achieved in the present invention, which comprises, in one aspect, a method of automatically generating tests for a software program based on metadata describing the program. In this aspect, metadata that defines characteristics of the software program is received. The metadata is parsed to identify information associated with output of the program. A plurality of instructions in a test language is generated. The instructions, when executed by a testing system, cause the testing system to perform the following steps. The program is caused to generate program output. The program output is tested to determine if the program properly generates it. Output is generated indicating whether the program output is properly displayed. The metadata may be stored in an XML document.
In another aspect, the invention provides a method of automatically generating tests for a software program based on metadata describing the program. A definition of a page hierarchy associated with the software program is received, representing output pages that are generated by the program in operation. The definition is parsed to identify information associated with one or more pages of the program. A plurality of instructions in a test language is generated. The instructions, when executed by a testing system, cause the testing system to perform the steps of: navigating through the page hierarchy and displaying each of the pages; determining whether each of the pages is properly displayed by the program; and generating output indicating whether each of the pages is properly displayed.
In yet another aspect, the invention provides a method of generating user interface tests for a software program based on metadata describing the program, comprising the steps of: receiving a definition of a page hierarchy associated with the software program, wherein the definition comprises an Extensible Markup Language (XML) document that conforms to a Document Type Definition (DTD) defining tags that define menu levels, menu level entries, screen identifiers, and security attributes of the pages; parsing the definition to identify one or more pages of the program; and generating a plurality of instructions in a test language. The instructions, when executed by a testing system, cause the testing system to perform the steps of: navigating through the page hierarchy and displaying each of the pages using a plurality of different navigation mechanisms, wherein the navigation mechanisms are selected from among: navigating and displaying using mouse clicks; navigating and displaying using menu acceleration keys; and navigating and displaying using a direct screen display call; determining whether each of the pages is properly displayed by the program after navigation using the plurality of different navigation mechanisms; and generating output indicating whether each of the pages is properly displayed.
In other aspects, the invention encompasses a computer apparatus and a computer readable medium configured to carry out the foregoing steps.
In general, embodiments leverage data-driven mechanisms that dynamically drive the visual representation of user interfaces offered to users of a software system. For example, in one specific embodiment, XML-structured data is used in the CiscoWorks 2000 product, from Cisco Systems, Inc., to describe web-based interfaces that an end user may access. Internally, these data files contain information describing the navigational constructs used to get at a task, such as the folder in which the task is presented, the URL that is launched when the task is selected, and the security permission level associated with the task.
Using this information, extracted from the XML files associated with a product, and an understanding of the information contained in the XML file, test code is automatically generated. In one embodiment, the automatically-generated code includes:
These tests can be reused on all succeeding releases of a given product. Further, the process for automatically generating the tests can be reused on every application that uses similarly constructed XML files to specify an interface. Further, because the tests are automatically generated, a suite of tests can automatically evolve as a product evolves.
In one embodiment, a commercial software system is used to recognize and validate objects that are displayed in a screen display and generated using HTML or JAVA (JAVA is a trademark of Sun Microsystems, Inc.). For example, the Mercury Interactive WinRunner system or the Rational Software RobotJ system may be used. Both such systems provide a programming language with callable functions. In WinRunner the language is TSL, a Mercury Interactive specific language; the script language for RobotJ is JAVA. In embodiments using these systems, the processes described below automatically generate TSL or JAVA functions that can validate screen objects. Sequencing function calls and reporting test results are accomplished by calling the TSL or JAVA functions using a script manager.
In certain embodiments, performing the approach described herein requires prior knowledge of the structure of the XML data in the files that describe application interfaces. Based on this knowledge, a parser and automatic code generator is created.
However, in alternate embodiments, the XML data is self-describing. In these embodiments, a generalized parser may be used, so that the total process is automated even further. In these embodiments, all XML data files that describe interfaces, URLs, roles, etc., contain meta-information that abstractly defines the elements of an XML that represents the navigational components, security components, URL components, etc. Using the meta-information, a single test generator script can generate test programs for any or all conforming XML files and web-based applications.
Using the approach described in this document for a suite of related applications, it is estimated that thousands of engineer-hours of effort are saved that could be used to develop more tests for application functionality. Additionally, as products evolve and change within a given release effort or over multiple release efforts, these tests can be automatically regenerated, saving additional engineering effort.
Thus, embodiments provide a way to use the information that is delivered as part of a software product to automate the generation of tests for all or part of a software product. Data used to drive a software product's user interfaces, and other aspects of the product, can be re-used to drive the automated development of tests for the product.
2.0 Automatically Generating Tests
According to one embodiment, a software developer uses a specified set of XML tags and semantics to define the structure and behavior of a user interface of a software product. In this context, “software product” refers to any software program, system or element for which tests are automatically developed using the approaches herein. An automated test generation process uses the XML tags to generate a series of test cases for the software product.
A site map system 102 generates a definition 104 of a page hierarchy of a software application. In this description, the terms “page” and “screen” are used synonymously to refer to visual output that is generated by a software application of interest. In certain embodiments, each page is an HTML document or Web page; however, any other form of screen display may be used. A content area system 106 generates a definition 108 of page content. Definitions 104, 108 are provided to runtime engine 120. Application logic 110 is also provided to runtime engine 120.
At run time, the definitions 104, 108 are combined with application logic 110 to result in application output 130. A bookmarking function 122, with other functions, forms part of and supports operations of runtime engine 122. Application output 130 may comprise one or more Web pages or other data that is generated in accordance with definitions 104,108.
In one embodiment, site map system 102 generates definition 104 in accordance with a site map grammar 102A. In one specific embodiment, site map grammar 102A is an Extensible Markup Language (XML) Document Type Definition (DTD), and definition 104 is generated in the form of an XML file. Appendix 1 to this description presents an example XML DTD that may be used for site map grammar 102A.
In this embodiment, definition 104 comprises a listing of all pages that comprise an application, an ordering of how the pages appear in a hierarchical menu system and the security characteristics of each page. Definition 104 also contains attributes for each page such as a unique page identifier, a reference to the content area, and a task ID. The unique page identifier (also termed a “screen ID” may be used to cause the application to generate a specific page by passing the application a URL that contains the screen ID as a parameter value. The task ID is used to perform a security authorization check for the user who is attempting to view the page.
In one specific embodiment, the structure and semantics of the XML tags are defined by a Site Map system, and specify a menu hierarchy, screen IDs, content areas, and security task IDs as specified in Table 1:
XML TAGS FOR MENU HIERARCHY DEFINITION
DEFINITION OF TAG
Menu level 1
Menu level 2
Menu level 3
Menu level 4
Menu level 1 entry
Menu level 2 entry
Menu level 3 entry
Menu level 4 entry
Content area and screen ID associated with a menu
A list of security attributes for authorization checking
A single security attribute
To illustrate a clear example, Table 1 identifies tags for a maximum of four menu levels; however, in other embodiments, there may be any number of levels. To further illustrate use of the Site Map system, assume that a hypothetical application has a menu structure as set forth in Table 2:
MENU STRUCTURE EXAMPLE
Based on this menu structure, site map system 102 of
SITE MAP XML REPRESENTATION OF MENU STRUCTURE
The bookmarking function 122 enables an application to display any screen defined in definition 104 directly, without navigating through the menu hierarchy. The bookmarking function is accessed by passing a screen identifier value as an argument to a root URL of the application. For example, the following URL will display screen ID 99 for application1 on a machine named myServer:
In one specific embodiment, network management applications are developed using a web application software framework to implement user interfaces. The framework, termed the UI Infrastructure (UII), is based on a basic screen design that divides all screens into two logical areas comprising a framework area and a content area. The framework area contains the items that are common to all application screens including a standard banner with company logo, application title, help and logout buttons, etc., and a menu system for navigation. The content area contains the application specific content and functionality.
The Picasso system includes two tools for designing user interfaces, one for specifying the information that will appear in the framework area for each screen called the site map tool, and another for creating the application specific content area layout for each screen. The output from the tools is used by a run time engine, the UII, for application deployment. The run time engine combines the static tool output with the dynamic data provided by the application logic to render the final run time application UI.
Further, the system of
Using this approach, one or more test results 180 are generated for evaluation by test personnel or an external system. Optionally, for example, when a large plurality of test scripts 160 are generated, a script manager 162 marshals the test scripts and provides them to testing system 170, facilitating management of the testing process. In one embodiment, test generator 150 is implemented as a JAVAŽ program that is configured to generate test scripts 160 in a language that the testing system 170 can process.
Thus, a combination of the bookmarking function 122 of runtime engine 120 and the information in definition 104 allows automated tests to be generated for any application that uses runtime engine 120. By parsing definition 104 to create a list of screen identifier values, every screen in the application under test can be systematically accessed to check whether a valid page is successfully produced by the application. In one embodiment, tests are automatically generated to navigate to each screen by three methods:
1. Simulating mouse clicks to select the screen through the menu hierarchy;
2. Simulating the key clicks associated with the menu acceleration keys;
3. Direct navigation to an application screen.
For purposes of illustrating a clear example, the foregoing three methods are identified. However, embodiments are not limited to these methods. If there are other methods available for interacting with the program under test, then tests may be generated to interact with the program using the other methods.
In addition, security attributes for each screen are obtained from definition 104. Based on the security attributes, each application page is systematically accessed using each security attribute. This allows every application screen to be checked to ensure that an authentication error is returned if a user does not have a required security attribute.
Furthermore, frameworks for detailed testing can be generated and application-function-specific tests added to that framework to test the details of the operation of the application.
An approach for using the system of
Referring first to
In block 206, the next page in the page hierarchy of the application under test is determined. Block 206 thus represents an initiation point for a programmatic loop that evaluates each page of the application, as represented by each leaf node described in a hierarchical tree in definition 104.
In block 208, for the then-current page, a test script is created. In the subsequent steps of block 210 through block 224, specific test script instructions or code is added to the test script. In one embodiment, testing system 170 of
In block 210, test script code is generated to set the then-current security level to the lowest level that the application under test allows. In one embodiment, the lowest allowable security level is known independently of the system of
Block 211 represents initiation of a loop in which the steps of block 212 to block 224, inclusive, are iterated for each security level that is recognized by the application under test. In block 212, the test script logs on to the application. In block 214, the test script issues simulated mouse clicks that navigate to and display the then current page. In block 216, a check of the then-current screen display is performed. In one embodiment, the steps of
In block 218, the test script issues simulated menu acceleration commands to navigate to and display the same page. In block 220, a check of the then-current screen display is again performed, for example, using the steps of
Referring now to
In block 232, optionally, a consolidated script is created to call all previously created scripts for pages in the application. For example, in one specific embodiment, a script file in the format used by a TestCafe application is created. The TestCafe script provides a way to manage, call, and monitor results for a plurality of individual page scripts. TestCafe is a test framework tool that has been internally developed by Cisco Systems, Inc.
Referring now to
In block 250, a test is performed to determine if the then-current security level is valid for the current screen. In one embodiment, the test of block 250 involves comparing the then-current security level, to a minimum security level associated with the current page. The minimum security level associated with the current page is determined by parsing definition 104 to identify a security level value for each page. In the examples given herein, the TaskID tag identifies a minimum security level value for each page.
If the current security level is invalid, then control passes to block 258, in which the system verifies that an “invalid user” screen, or the equivalent, has been displayed. Processing then completes at block 256. Alternatively, if the current security level is valid, then in block 252, test script code checks whether all objects in the screen are present on the screen. Block 252 uses native functions of applications such as WinRunner or RobotJ to determine whether objects are present. The objects that are expected to form part of a screen are determined by WinRunner or RobotJ by parsing a description of the screen that is separately provided, to result in creating and storing a tree of objects in memory.
In block 254, a function template is created in the test script code for other page-specific tests. Block 254 provides a way to link hard-coded, manually created tests that are specific to a particular page into the test script. This enables a test engineer or other user to include code to test other aspects of the program under test, including aspects other than the GUI. In one embodiment, block 254 involves creating a function template for testing system 170, in which the then-current screen identifier is used as a name for the template. The function template may be filled with separately created test code thereafter. In block 256, processing is complete. For example, control returns to a section of test code that called the process of
The test script that results from the foregoing processes may be used as a framework for more complete, application-specific testing. Unlike prior approaches, there is no separate process needed to generate such a framework.
Appendix 2 to this description presents a complete site map XML file example, including all required tags and attributes. Appendix 3 to this description presents an example implementation. Appendix 4 presents a JAVA parser implementation. Based on the structure of the XML registry file shown in Appendix 3, the JAVA code of Appendix 4 was written to parse the XML files and generate test scripts formatted in WinRunner Test Scripting Language (“TSL”) that test the behavior of the tasks specified in the XML file. Appendix 5 presents an example of WinRunner test script code that was automatically generated.
The example of Appendices 2, 3, 4, and 5 does not use the example XML tags specified above with reference to definition 104. Instead, the example uses XML files associated with CiscoWorks 2000 Common Management Framework (“CMF”), from Cisco Systems, Inc. As in the case of definition 104 described above, the CMF XML files control web page navigation and security. The tags and semantics of the CMF registry files are used to parse the XML file of a specific application within the Campus Manager product, and transform it into an automated test for that application. Examples of the CMF XML tags used in the appendices are MENU, MENUBAR, and TOOLBAR.
3.0 Implementation Mechanisms—Hardware Overview
Computer system 400 may be coupled via bus 402 to a display 412, such as a cathode ray tube (“CRT”), for displaying information to a computer user. An input device 414, including alphanumeric and other keys, is coupled to bus 402 for communicating information and command selections to processor 404. Another type of user input device is cursor control 416, such as a mouse, trackball, stylus, or cursor direction keys for communicating direction information and command selections to processor 404 and for controlling cursor movement on display 412. This input device typically has two degrees of freedom in two axes, a first axis (e.g., x) and a second axis (e.g., y), that allows the device to specify positions in a plane.
The invention is related to the use of computer system 400 for generating tests based on software product contents. According to one embodiment of the invention, generating tests based on software product contents is provided by computer system 400 in response to processor 404 executing one or more sequences of one or more instructions contained in main memory 406. Such instructions may be read into main memory 406 from another computer-readable medium, such as storage device 410. Execution of the sequences of instructions contained in main memory 406 causes processor 404 to perform the process steps described herein. In alternative embodiments, hard-wired circuitry may be used in place of or in combination with software instructions to implement the invention. Thus, embodiments of the invention are not limited to any specific combination of hardware circuitry and software.
The term “computer-readable medium” as used herein refers to any medium that participates in providing instructions to processor 404 for execution. Such a medium may take many forms, including but not limited to, non-volatile media, volatile media, and transmission media. Non-volatile media includes, for example, optical or magnetic disks, such as storage device 410. Volatile media includes dynamic memory, such as main memory 406. Transmission media includes coaxial cables, copper wire and fiber optics, including the wires that comprise bus 402. Transmission media can also take the form of acoustic or light waves, such as those generated during radio wave and infrared data communications.
Common forms of computer-readable media include, for example, a floppy disk, a flexible disk, hard disk, magnetic tape, or any other magnetic medium, a CD-ROM, any other optical medium, punchcards, papertape, any other physical medium with patterns of holes, a RAM, a PROM, and EPROM, a FLASH-EPROM, any other memory chip or cartridge, a carrier wave as described hereinafter, or any other medium from which a computer can read.
Various forms of computer readable media may be involved in carrying one or more sequences of one or more instructions to processor 404 for execution. For example, the instructions may initially be carried on a magnetic disk of a remote computer. The remote computer can load the instructions into its dynamic memory and send the instructions over a telephone line using a modem. A modem local to computer system 400 can receive the data on the telephone line and use an infrared transmitter to convert the data to an infrared signal. An infrared detector can receive the data carried in the infrared signal and appropriate circuitry can place the data on bus 402. Bus 402 carries the data to main memory 406, from which processor 404 retrieves and executes the instructions. The instructions received by main memory 406 may optionally be stored on storage device 410 either before or after execution by processor 404.
Computer system 400 also includes a communication interface 418 coupled to bus 402. Communication interface 418 provides a two-way data communication coupling to a network link 420 that is connected to a local network 422. For example, communication interface 418 may be an integrated services digital network (“ISDN”) card or a modem to provide a data communication connection to a corresponding type of telephone line. As another example, communication interface 418 may be a local area network (“LAN”) card to provide a data communication connection to a compatible LAN. Wireless links may also be implemented. In any such implementation, communication interface 418 sends and receives electrical, electromagnetic or optical signals that carry digital data streams representing various types of information.
Network link 420 typically provides data communication through one or more networks to other data devices. For example, network link 420 may provide a connection through local network 422 to a host computer 424 or to data equipment operated by an Internet Service Provider (“ISP”) 426. ISP 426 in turn provides data communication services through the worldwide packet data communication network now commonly referred to as the “Internet” 428. Local network 422 and Internet 428 both use electrical, electromagnetic or optical signals that carry digital data streams. The signals through the various networks and the signals on network link 420 and through communication interface 418, which carry the digital data to and from computer system 400, are exemplary forms of carrier waves transporting the information.
Computer system 400 can send messages and receive data, including program code, through the network(s), network link 420 and communication interface 418. In the Internet example, a server 430 might transmit a requested code for an application program through Internet 428, ISP 426, local network 422 and communication interface 418. In accordance with the invention, one such downloaded application provides for generating tests based on software product contents as described herein.
The received code may be executed by processor 404 as it is received, and/or stored in storage device 410, or other non-volatile storage for later execution. In this manner, computer system 400 may obtain application code in the form of a carrier wave.
4.0 Extensions and Alternatives
In the foregoing specification, the invention has been described with reference to specific embodiments thereof. It will, however, be evident that various modifications and changes may be made thereto without departing from the broader spirit and scope of the invention. The specification and drawings are, accordingly, to be regarded in an illustrative rather than a restrictive sense.
The foregoing example embodiments are illustrated in the context of user interface testing with an XML DTD having tags that relate to user interface structure, and a runtime engine that provides a bookmarking function. One example using XML page hierarchy output from the Site Map tool of the Cisco UII is given, and another example uses XML semantics associated with CMF. However, alternative embodiments may operate in the context of testing any other aspect of a program that is capable of description in any form of metadata.
In one alternative, applicable to JAVA code, information necessary to develop test programs for the methods of a class is provided in the “javadoc” documentation that is associated with the class. The “javadoc” documentation contains information about all methods that are exposed, as well as an acceptable range of values for parameters and all possible return codes. Test programs for these methods may be automatically generated to test valid and invalid range processing, and to generate of all possible error codes. Further, information about all methods that are exposed could also be derived by inspection of the classes.
A set of metadata that defines alternative tags, and a mapping of the alternative tags to the tags of the XML DTD defined herein, may drive operation of the parser and permit automatic generation of tests. Thus, the semantics of the tags defined herein may be mapped to different tags that are intended for use with a different application or framework. Accordingly, the parser and automatic test generator herein are extensible, and the techniques herein are applicable to any programming framework that provides a metadata description of a program or interface.
Further, the approaches herein may be used with applications other than Web-based applications. For example, a network device operating system could include a metadata file that describes the command set for the operating system. The parser and automatic test generator described herein may receive such a metadata file and automatically generate network device operating system tests. As a specific example, assume that each executable image of the Cisco Internetworking Operating System (IOS) contains a readable file that defines all Command Line Interface (CLI) commands supported by that image, and a definition of the semantics of the CLI commands. Test generator 150 reads the file and generates a test program that dispatches one or more CLI commands to a network device that is executing the IOS image. The order of the CLI commands may be determined by an evaluation of semantics of the CLI.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US5754755 *||Oct 10, 1996||May 19, 1998||Microsoft Corporation||Method and system for generating test scripts|
|US6523172 *||Feb 19, 1999||Feb 18, 2003||Evolutionary Technologies International, Inc.||Parser translator system and method|
|US6772083 *||Sep 3, 2002||Aug 3, 2004||Sap Aktiengesellschaft||Computer program test configurations with data containers and test scripts|
|US6826727 *||Nov 24, 1999||Nov 30, 2004||Bitstream Inc.||Apparatus, methods, programming for automatically laying out documents|
|US6920608 *||May 18, 2000||Jul 19, 2005||E Numerate Solutions, Inc.||Chart view for reusable data markup language|
|US6993747 *||Aug 14, 2000||Jan 31, 2006||Empirix Inc.||Method and system for web based software object testing|
|US20020120919 *||Dec 27, 2000||Aug 29, 2002||International Business Machines Corporation||Monitoring execution of an hierarchical visual program such as for debugging a message flow|
|US20020188890 *||Jun 4, 2002||Dec 12, 2002||Shupps Eric A.||System and method for testing an application|
|US20030070119 *||Oct 10, 2001||Apr 10, 2003||Dallin Michael Dean||Method and system for testing a software product|
|US20040025083 *||Jul 31, 2002||Feb 5, 2004||Murthi Nanja||Generating test code for software|
|1||*||"Controlling Web Page Access", Indiana University Webmaster, pp. 1-12, http://web.archive.org/web/20010420041619/http://www.indiana.edu/~wmhome/security<SUB>-</SUB>info/index.shtml.|
|2||*||"Rational Robot Automated Test", by the Rational Company, pp. 1-14, http://web.archive.org/web/20020815182746/http://wilsonmar.com/1robot.htm, Aug. 15, 2002.|
|3||Kjell Arne Barmsnes et al., "PICASSO: A User Interface Management System for Real-Time Applications," paper presented at workshop on "User Interfaces for Expert Systems", London, Mar. 11-12, 1992, pp. 1-12.|
|4||Mercury Interactive Corporation, "WinRunner," 2002, 2 pages.|
|5||Mercury Interactive Corporation, "WinRunner," http://www-scva.mercuryinteractive.com/cgi-bin/display/printer<SUB>-</SUB>friendly.cgi, printed Jan. 29, 2003, 1 page.|
|6||Mercury Interactive Corporation, Testing Java Applets and Applications, 1999, 9 pages.|
|7||Mercury Interactive Corporation, WinRunner, http://www-svca.mercuryinteractive.com/cgi-bin/display/printer<SUB>-</SUB>friendly.cgi, printed Jan. 29, 2003, 1 page.|
|8||Rational, "Overview," http://www.rational.com/products/robot/prodinof.jsp, printed Jan 29, 2003, pp. 1-3.|
|9||Rational, "Rational Robot," 2001, 2 pages.|
|10||Tom Arnold, "A First Look: Rational RobotJ 1.0," 2002, pp. 14 pages.|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US7546586 *||Feb 15, 2005||Jun 9, 2009||Microsoft Corporation||Multi-Interface aware scenario execution environment|
|US7603658 *||Nov 17, 2004||Oct 13, 2009||Oracle International Corporation||Application functionality for a test tool for application programming interfaces|
|US7631227||Nov 21, 2006||Dec 8, 2009||Etaliq Inc.||Automated testing and control of networked devices|
|US7703005 *||May 17, 2005||Apr 20, 2010||Bea Systems, Inc.||Method to generate scripts from XML|
|US7712074 *||Nov 21, 2002||May 4, 2010||Bing Ren||Automating interactions with software user interfaces|
|US7856619 *||Mar 31, 2006||Dec 21, 2010||Sap Ag||Method and system for automated testing of a graphic-based programming tool|
|US7917524 *||Jun 27, 2006||Mar 29, 2011||Sap Ag||Systems and methods for providing a mockup data generator|
|US7950000 *||May 24, 2011||Microsoft Corporation||Architecture that restricts permissions granted to a build process|
|US8069439 *||Mar 30, 2006||Nov 29, 2011||Microsoft Corporation||Framework for modeling continuations in workflows|
|US8074204 *||Dec 6, 2011||Microsoft Corporation||Test automation for business applications|
|US8141047 *||Jan 7, 2008||Mar 20, 2012||International Business Machines Corporation||Dependent object framework for junit testing and software application component|
|US8458664 *||Jun 4, 2013||International Business Machines Corporation||Command line interface permutation executor|
|US8595697 *||Jul 1, 2009||Nov 26, 2013||International Business Machines Corporation||Serializing a templated markup language representation of test artifacts|
|US8627295 *||Oct 9, 2009||Jan 7, 2014||General Electric Company||Methods and apparatus for testing user interfaces|
|US8667467 *||Jul 26, 2010||Mar 4, 2014||Sap Aktiengesellschaft||Dynamic test scripts|
|US8713544 *||Nov 25, 2003||Apr 29, 2014||Symantec Corporation||Universal data-driven computer proxy|
|US8725748 *||Aug 27, 2004||May 13, 2014||Advanced Micro Devices, Inc.||Method and system for storing and retrieving semiconductor tester information|
|US8799866||May 31, 2011||Aug 5, 2014||International Business Machines Corporation||Automatic generation of user interfaces|
|US8949795 *||Aug 23, 2012||Feb 3, 2015||International Business Machines Corporation||Generating test cases for covering enterprise rules and predicates|
|US8954933||May 31, 2011||Feb 10, 2015||International Business Machines Corporation||Interactive semi-automatic test case maintenance|
|US8972946||Aug 8, 2012||Mar 3, 2015||International Business Machines Corporation||Interactive semi-automatic test case maintenance|
|US9081881||Dec 18, 2008||Jul 14, 2015||Hartford Fire Insurance Company||Computer system and computer-implemented method for use in load testing of software applications|
|US9189374 *||Jun 29, 2010||Nov 17, 2015||Zte Corporation||Automatic test system for distributed comprehensive service and method thereof|
|US9231896||Jul 13, 2015||Jan 5, 2016||Hartford Fire Insurance Company||Computer system and computer-implemented method for service and application load testing|
|US9292624||Sep 30, 2013||Mar 22, 2016||Globalfoundries Inc.||String generation tool|
|US9305117||Nov 6, 2013||Apr 5, 2016||Globalfoundries Inc.||String generation tool|
|US20040100502 *||Nov 21, 2002||May 27, 2004||Bing Ren||Automating interactions with software user interfaces|
|US20050193291 *||Nov 17, 2004||Sep 1, 2005||Oracle International Corporation||Application functionality for a test tool for application programming interfaces|
|US20050210448 *||Mar 17, 2004||Sep 22, 2005||Kipman Alex A||Architecture that restricts permissions granted to a build process|
|US20050262476 *||May 17, 2005||Nov 24, 2005||Bea Systems, Inc.||Method to generate scripts from XML|
|US20060010426 *||Jul 9, 2004||Jan 12, 2006||Smartware Technologies, Inc.||System and method for generating optimized test cases using constraints based upon system requirements|
|US20060015840 *||Mar 30, 2005||Jan 19, 2006||Wendall Marvel||Parameter-based software development, distribution, and disaster recovery|
|US20060183085 *||Feb 15, 2005||Aug 17, 2006||Microsoft Corporation||Multi-interface aware scenario execution environment|
|US20070234121 *||Mar 31, 2006||Oct 4, 2007||Sap Ag||Method and system for automated testing of a graphic-based programming tool|
|US20070239499 *||Mar 30, 2006||Oct 11, 2007||Microsoft Corporation||Framework for modeling continuations in workflows|
|US20070240040 *||Apr 5, 2006||Oct 11, 2007||Christopher Peters||Non-compiled portable algorithm|
|US20080010074 *||Jun 27, 2006||Jan 10, 2008||Sap Ag.||Systems and methods for providing a mockup data generator|
|US20080115114 *||Nov 10, 2006||May 15, 2008||Sashank Palaparthi||Automated software unit testing|
|US20080120521 *||Nov 21, 2006||May 22, 2008||Etaliq Inc.||Automated Testing and Control of Networked Devices|
|US20080120602 *||Nov 21, 2006||May 22, 2008||Microsoft Corporation||Test Automation for Business Applications|
|US20090178029 *||Jan 7, 2008||Jul 9, 2009||International Business Machines Corporation||Dependent Object Framework for JUnit Testing|
|US20100030874 *||Feb 4, 2010||Louis Ormond||System and method for secure state notification for networked devices|
|US20100162263 *||Dec 18, 2008||Jun 24, 2010||Hartford Fire Insurance Company||Computer system and computer-implemented method for use in load testing of software applications|
|US20100228789 *||Sep 9, 2010||Mario Gonzalez Macedo||Command line interface permutation executor|
|US20100281457 *||Nov 4, 2010||Bing Ren||Automating interactions with software user interfaces|
|US20110004865 *||Jan 6, 2011||International Business Machines Corporation||Serializing a templated markup language representation of test artifacts|
|US20110088018 *||Oct 9, 2009||Apr 14, 2011||General Electric Company, A New York Corporation||Methods and apparatus for testing user interfaces|
|US20120023485 *||Jan 26, 2012||Sap Ag||Dynamic Test Scripts|
|US20120124495 *||Nov 23, 2009||May 17, 2012||Nitsan Amichai||System and method for object relationship identification in a user interface|
|US20120221279 *||Jun 29, 2010||Aug 30, 2012||Zte Corporation||Automatic Test System for Distributed Comprehensive Service and Method Thereof|
|US20130346982 *||Jun 22, 2012||Dec 26, 2013||Microsoft Corporation||Generating a program|
|US20140059522 *||Aug 23, 2012||Feb 27, 2014||International Business Machines Corporation||Generating Test Cases for Covering Enterprise Rules and Predicates|
|EP2504748A1 *||Nov 23, 2009||Oct 3, 2012||Hewlett-Packard Development Company, L.P.||System and method for object relationship identification in a user interface|
|EP2504748A4 *||Nov 23, 2009||Jul 24, 2013||Hewlett Packard Development Co||System and method for object relationship identification in a user interface|
|WO2008061340A1 *||Nov 15, 2007||May 29, 2008||Etaliq Inc.||Automated testing and control of networked devices|
|WO2011062597A1 *||Nov 23, 2009||May 26, 2011||Hewlett-Packard Development Company, L.P.||System and method for object relationship identification in a user interface|
|U.S. Classification||717/124, 714/E11.207, 714/38.14|
|International Classification||G06F11/00, G06F9/44|
|Cooperative Classification||G06F2201/865, G06F11/3414, G06F11/3688, G06F9/4443|
|European Classification||G06F11/36T2E, G06F9/44W|
|Sep 17, 2002||AS||Assignment|
Owner name: CISCO TECHNOLOGY, INC., CALIFORNIA
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:RIGGINS, MICHAEL;HEWITT, JEFFREY;FELDSTEIN, JEFFREY;REEL/FRAME:013308/0626;SIGNING DATES FROM 20020910 TO 20020913
|Jun 24, 2008||CC||Certificate of correction|
|Mar 18, 2011||FPAY||Fee payment|
Year of fee payment: 4
|Mar 18, 2015||FPAY||Fee payment|
Year of fee payment: 8