Automated Test Case Generation from Legacy GUIs
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Software development projects face inefficiencies and inaccuracies in generating test cases and production data from Graphical User Interface Applications (GUIs) for web services, due to the complexity of closed and monolithic GUIs, which hinders interoperability and increases costs.
Innovation Solution
The SMART system treats GUIs as state machines, using structural representations of GUIs and GUI elements to generate test data and cases without modifying the source code, and works with Coins to compose integrated systems, enabling non-invasive extraction and reuse of test data and production data across applications.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If developers extract test cases from closed and monolithic GUI applications, then test data can be obtained for testing, but the process becomes extremely difficult and time-consuming due to the lack of exposed programming interfaces
Solution Approach 1:
The patent introduces an intermediary layer that captures GUI events and state transitions without requiring access to the underlying source code. This intermediary mechanism translates user interactions with the closed GUI into structured test case data, effectively bridging the gap between the inaccessible application internals and the testing framework.
Solution Approach 2:
The system creates copies of GUI event sequences and state transitions by observing and recording user interactions. These copies serve as test data representations that capture the essential behavior of the application without needing to access or modify the original source code, enabling test case generation from the captured interaction patterns.
2Reliability
If developers analyze source code and data structures of reference applications to extract test data, then comprehensive test cases can be generated, but significant time and money are spent on understanding complex legacy systems
Solution Approach 1:
The system enables self-service test data extraction by automatically capturing GUI events and state transitions through observation of user interactions. This eliminates the need for manual source code analysis, as the system generates test data autonomously by monitoring and recording the application's observable behavior during normal operation.
Solution Approach 2:
The patent replaces the mechanical process of manual source code analysis with an automated observation and capture mechanism. Instead of requiring developers to physically examine and understand complex code structures, the system substitutes this with automated event logging and state tracking that occurs transparently during application execution.
3Quantity of substance
If organizations preserve test data from reference applications deployed in production, then valuable testing resources are available, but extraction and development of test cases remains difficult without access to original implementation details
Solution Approach 1:
The system introduces an intermediary capture mechanism that interfaces with the running application through its GUI layer, allowing test data extraction without requiring access to the original implementation details or data structures. This intermediary layer translates observable GUI events into extractable test case formats.
Solution Approach 2:
The system changes the parameters of test data extraction from requiring source code access and deep understanding of data structures to simply observing and capturing GUI event parameters. By transforming the extraction process to work with observable external parameters rather than internal implementation parameters, the system makes extraction feasible from production deployments.
4Reliability
If developers use laborious and inefficient methods to generate test cases, then test coverage can be achieved, but the process produces inaccurate and incomplete test cases that fail to meet testing requirements
Solution Approach 1:
The patent replaces manual, laborious test case generation methods with an automated system that captures GUI events and state transitions programmatically. This substitution eliminates the inefficiencies and inaccuracies of manual methods by using systematic, repeatable automated processes that consistently generate complete and accurate test cases.
Solution Approach 2:
The system incorporates feedback mechanisms that monitor GUI state transitions and use this information to generate appropriate test cases. The feedback loop ensures that test cases accurately reflect the actual behavior and state changes of the application, improving test case quality by basing them on observed reality rather than manual interpretation.
Data Source
Figure 1
Figure 2
Figure 3
AI summary
A system for application reference testing (SMART) solves the technical problem of generating test data and test cases from graphical user interface applications (GAPs) to test web services, effectively and non-invasively. SMART allows organizations to easily and promptly identify and resolve software bugs, ensure higher quality software and development productivity, complete software projects faster, deliver software products to market quicker, and improve the return on investment for software development projects. SMART provides a user friendly visualization mechanism that interacts with an accessibility layer to enable organizations to economically and easily define user interactions with GAPs, by performing point-and-click, drag-and-drop operations on the GAPs, and generate reusable test data and test cases for web services.