Automated Functional Test Generation for Re-hosted Legacy Applications
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Legacy applications, such as COBOL applications on mainframes, face challenges in functional verification during re-hosting due to the lack of available test cases and software requirements specifications, leading to labor-intensive and error-prone verification processes when migrating to newer systems like Microsoft Windows or Linux.
Innovation Solution
A system and method that analyzes source code to generate functional tests by extracting user-input scenarios and output responses, using Abstract Syntax Trees and Control Flow Graphs to ensure all possible paths are tested, thereby automatically generating comprehensive test scenarios for re-hosted applications.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If manual test case creation is used for re-hosted applications, then test coverage can be achieved, but the verification process becomes labor intensive and error prone
Solution Approach 1:
The system performs self-service by automatically generating test cases from the source code itself. The test case generation process uses the application's own code structure, control flow graphs, and data flow information to create comprehensive test scenarios without requiring external test documentation or manual intervention, thereby eliminating human errors while maintaining high test coverage
Solution Approach 2:
The system performs preliminary action by analyzing the source code structure, building control flow graphs, and identifying all possible execution paths before test case execution. This preliminary analysis of the code's control flow and data flow enables the automatic generation of complete test cases that cover all scenarios, eliminating the need for manual test design while ensuring comprehensive coverage
2Extent of automation
If automatic test case generation techniques based on software requirements specifications are used, then test case generation can be automated, but these techniques cannot be applied to legacy applications lacking such documentation
Solution Approach 1:
The system inverts the traditional approach by generating test cases from the source code itself rather than from external documentation. Instead of requiring software requirements specifications and design artifacts as input, the system parses the legacy application code, builds control flow graphs, and extracts test scenarios directly from the code structure, making automation applicable to undocumented legacy systems
Solution Approach 2:
The system introduces an intermediary approach by using control flow graph analysis as a bridge between the source code and test case generation. The control flow graph serves as an intermediate representation that captures all execution paths, enabling automatic test case generation without requiring external documentation while maintaining the systematic approach of traditional automation methods
3Ease of operation
If testers create functional test cases based on their understanding of system functionality, then test cases can be generated without source code analysis, but some functionalities might be missed leaving parts of the application untested
Solution Approach 1:
The system performs self-service by automatically generating test cases from the source code itself. The test case generation process uses the application's own code structure, control flow graphs, and data flow information to create comprehensive test scenarios without requiring external test documentation or manual intervention, thereby eliminating human errors while maintaining high test coverage
Solution Approach 2:
The system implements feedback by using control flow graph analysis to identify all possible execution paths and ensuring that generated test cases cover every path. This systematic feedback mechanism guarantees that no functionality is missed, as the control flow graph provides complete information about the application's structure and behavior, eliminating gaps in test coverage
Data Source
AI summary
A system and method for generating functional tests to verify code migrated from a first host to a second host. In one embodiment, source code is analyzed in order to generate functional tests that can be used for testing the re-hosted application. In particular, user-input scenarios are extracted from the source code and system output responses are determined based on the user-input scenarios. Functional tests can then be generated using the extracted user-input scenarios and output responses to ensure that the re-hosted application responds in a like manner.