Component Test Code Generation for Application Testing
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing network computer application test automation methods, such as capture/playback tools, are ineffective in designing and implementing practical test suites, require high technical proficiency, and struggle with integrating test design and automation, leading to inefficiencies and errors in iterative software modifications.
Innovation Solution
A system and method for generating component test code using a custom engine and function libraries in an application test generation program, allowing users to define components and object repositories, which enables non-technical Subject Matter Experts to design and implement test automation without coding, using a role-based testing model and automated code generation.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Extent of automation
If capture/playback tools are used for test automation, then automation of testing is achieved, but the tools are ineffective in designing and implementing practical test suites and require high technical proficiency
Solution Approach 1:
The patent introduces a custom engine as an intermediary between the user and the test automation system. This custom engine provides a simplified, user-friendly interface that translates high-level test design intentions into automated test code, eliminating the need for users to directly interact with complex automation frameworks. The custom engine acts as a mediator that bridges the gap between non-technical users and the automation system.
Solution Approach 2:
The patent replaces the traditional mechanical approach of manual test execution with an automated code generation system. Instead of requiring users to manually write and execute test scripts, the system automatically generates test code based on user-defined components and object repositories, substituting the manual coding process with automated generation.
2Adaptability or versatility
If manual application testing is performed, then test design flexibility is maintained, but excessive retesting is required for iterative modifications
Solution Approach 1:
The patent segments the test automation system into distinct modular components: custom engine, function libraries, object repositories, and test components. This segmentation allows each component to be independently designed, maintained, and updated. When the application under test changes, only the relevant segments need to be updated, not the entire test suite, thereby maintaining flexibility while improving productivity.
Solution Approach 2:
The patent implements dynamic test generation where the test code is automatically adapted based on the selected components and object repositories. The system can dynamically adjust test cases according to iterative modifications in the application, allowing test designs to evolve alongside the software without requiring complete retesting.
3Ease of manufacture
If automated code generation is used, then coding requirements are minimized for non-technical experts, but the system complexity increases
Solution Approach 1:
The patent extracts the complex coding logic from the user interface and places it within the custom engine and function libraries. The complexity is taken out of the user's responsibility and encapsulated within the automated generation system. Users only need to define high-level test components and select from pre-configured object repositories, while the complex code generation is handled by the extracted automation engine.
Solution Approach 2:
The custom engine serves multiple functions: it provides the user interface, manages object repositories, generates test code, and executes tests. By consolidating these diverse functions into a single multi-functional system, the patent reduces the overall system complexity that users would otherwise need to manage across multiple separate tools.
4Ease of repair
If modularized test components are used, then reuse and maintenance are facilitated, but the initial setup complexity increases
Solution Approach 1:
The patent performs preliminary action by pre-configuring object repositories and defining standard components before the actual testing begins. Users inherit these pre-established structures and only need to select and combine existing components rather than creating everything from scratch. This preliminary setup, while initially complex, is performed once and then reused across multiple test cases, significantly reducing ongoing setup complexity.
Data Source
AI summary
Systems and methods described here include embodiments for generating component test code for use in an application test generation program used to test an application under test. Certain embodiments include a computer server running the application test generation program with an integrated custom engine and function libraries, the custom engine configured to allow a user to define a component, allow the user to select at least one application area, allow the user to define a component step for the defined component, wherein defining a component step includes, an object repository associated with the selected application area, at least one object option associated with the selected object repository, wherein the selection of the object option determines subsequent sets of object options for selection by the user, repeating, and to generate the component test code, via associations in the function libraries between component test code portions and the defined component steps.