Verifying control coupling and data coupling analysis in testing of software code that implements components; identifying control couples by performing static analysis on the source code; defining and executing control couple test runs of the software code including of the identified control couples that test runs using dynamic analysis; identifying control coupling coverage of the source file based on the dynamic analysis; identifying data couples within the source file, the data couples being a variable and a parameter of the components; defining data couple tests for each of the components containing of the identified data couples, the data couple tests using dynamic analysis; executing the data couple tests on the source file; identifying data coupling variable use coverage of the source file based on the dynamic analysis; and generating a report based on the identified control couple coverage and identified data coupling variable use coverage of the source file.
Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
2. The method of claim 1, wherein the data couples include data couples arising from parameter couples associated with call into and out of components of the source file.
This invention relates to software analysis, specifically tracking data flow and dependencies within source code. The problem addressed is the difficulty in identifying how data propagates through software components, particularly when functions or methods are called with parameters that carry data into or out of those components. Existing methods may not adequately capture these dynamic interactions, leading to incomplete dependency analysis. The invention describes a method for analyzing source code to identify data couples, which are relationships between data elements that arise from parameter passing during function calls. These data couples are derived from parameter couples, which represent the input and output parameters of function calls. By tracking these parameter couples, the method determines how data flows into and out of software components, such as functions, classes, or modules. The analysis helps in understanding dependencies, improving code maintainability, and detecting potential issues like unintended side effects or data leaks. The method involves parsing the source code to identify function calls and their associated parameters, then mapping these parameters to data elements within the code. The resulting data couples provide a detailed view of how data is transferred between components, enabling more accurate dependency graphs and better software analysis. This approach enhances static analysis tools by incorporating dynamic-like insights without requiring runtime execution.
3. The method of claim 1, wherein each of the one or more data couple tests is individually executable.
A system and method for testing data coupling in software applications addresses the challenge of ensuring data integrity and consistency across interconnected systems. The invention provides a framework for verifying data relationships and dependencies between different data elements or modules within a software environment. The core method involves generating one or more data coupling tests, where each test is designed to validate specific data interactions or transformations. These tests are individually executable, meaning they can be run independently to assess individual data coupling scenarios without requiring the execution of other tests. This modular approach allows for targeted testing of specific data relationships, improving efficiency and debugging capabilities. The system may also include mechanisms for defining test conditions, executing the tests, and analyzing the results to identify any inconsistencies or errors in data coupling. The ability to run tests individually enhances flexibility, enabling developers to focus on particular data interactions or troubleshoot specific issues without running an entire test suite. This method is particularly useful in complex software systems where data integrity is critical, such as in financial applications, enterprise resource planning (ERP) systems, or any environment where data consistency must be maintained across multiple modules or components.
7. The method of claim 1, wherein the report includes a sixth section having a first table indicating the control couples of the one or more identified control couples that originate from each of the one or more components of the source file and a second table indicating the control couples of the one or more identified control couples where the destination of the control couple is one of the one or more components of the source file.
This invention relates to software analysis, specifically to generating detailed reports on control flow within a source file. The problem addressed is the need for a structured breakdown of control dependencies between components in a source file, particularly to identify how control flows originate from and terminate within those components. The method involves analyzing a source file to identify control couples, which are directional relationships where one component influences the execution of another. The report generated includes a sixth section with two tables. The first table lists control couples originating from each component in the source file, showing which components initiate control flow. The second table lists control couples where the destination is a component in the source file, showing which components receive control flow. This structured presentation helps developers and analysts understand the control dependencies between components, aiding in debugging, optimization, and maintenance. The analysis may involve parsing the source code to identify control structures like function calls, conditional branches, and loops, then mapping these into control couples. The tables provide a clear visualization of control flow patterns, highlighting potential bottlenecks or critical paths in the software. This approach is particularly useful for large or complex codebases where manual analysis would be impractical.
8. The method of claim 7, wherein the first table and the second table include a first column identifying a call-from point between the one or more identified control couples, a second column identifying a call-to point between the one or more identified control couples, a third column indicating a destination source file the call-to or call-from is to, a fourth column indicating a software code line of the source file where each of the one or more identified control couples are located, and a fifth column indicating a control coverage of the one or more identified control couples based on the dynamic analysis.
9. The method of claim 8, wherein the fourth section includes source code of the source file associated with the first table and the second table.
A system and method for managing and analyzing software source code involves organizing code into structured tables and sections to improve traceability and debugging. The system addresses challenges in tracking code changes, dependencies, and relationships between different parts of a software project, which can lead to inefficiencies in development and maintenance. The method includes creating a first table that maps a source file to a first section of a document, where the first section contains metadata about the source file, such as its name, location, and version. A second table maps the source file to a second section of the document, where the second section includes a description of the source file's functionality. A third table maps the source file to a third section of the document, which contains a list of dependencies or related files. A fourth section of the document includes the actual source code of the source file, allowing developers to directly access and review the code alongside its metadata and documentation. This structured approach ensures that all relevant information about a source file is centralized, improving code navigation and reducing the time spent searching for dependencies or understanding functionality. The system enhances collaboration by providing a unified view of code and its context, making it easier for teams to maintain and update software projects efficiently.
10. The method of claim 1, wherein the report includes a seventh section having a third table indicating the data couples of the one or more identified data couples that originate from each of the one or more components of the source file and a fourth table indicating the data couples of the one or more identified data couples where the destination of the data couple is one of the one or more components of the source file, the third table and the fourth table being results for one of the one or more tests.
11. The method of claim 10, wherein the seventh section is repeated for each of the executed one or more data couple tests.
A system and method for automated data validation and testing involves executing one or more data couple tests to verify data integrity and consistency. The method includes a sequence of steps to prepare test environments, generate test data, execute tests, and analyze results. A seventh section of the process involves validating test outcomes by comparing expected results with actual results, identifying discrepancies, and generating reports. This validation step is repeated for each executed data couple test to ensure comprehensive verification. The method may also include additional steps such as configuring test parameters, logging test execution details, and storing results for future reference. The system is designed to improve data accuracy and reliability in automated testing environments by systematically validating test outcomes across multiple test iterations. The approach reduces manual intervention and enhances efficiency in data validation processes.
12. The method of claim 10, wherein the third table includes a first column identifying the variable of one of the identified one or more data couples, a second column indicating a software code line of the source file where variable is located, a third column identifying a variable type of the variable, a fourth column identifying a parameter of the one or more components coupled to the variable, a fifth column identifying the component containing the identified parameter, a sixth column identifying a source code line where the parameter calls the variable, and a seventh column identifying a component of the source file containing the component.
13. The method of claim 10, wherein the fourth table includes a first column identifying the variable of one of the identified one or more data couples, a second column identifying a destination component of the variable, a third column identifying a source code line of the source file where the variable is called, a fourth column identifying a component of the source file containing the component calling the variable, a fifth column identifying a variable type of the variable, a sixth column identifying a parameter of the one or more components coupled to the variable, and a seventh column identifying a source code line where the parameter is located.
14. The method of claim 10, wherein the seventh section includes a fourth table, the fourth table including a first column identifying a variable of the source file, a second column identifying the source file containing the variable, a third column identifying a component within the source file containing the variable, a fourth column identifying a variable type of the variable, a fifth column identifying an attribute of the variable, and a sixth column identifying the source code lines of the source code file in which the variable is used.
This invention relates to a method for analyzing and organizing information about variables in source code files. The method addresses the challenge of efficiently tracking and managing variable data across large software projects, where variables may be scattered across multiple files and components, making it difficult to understand their usage, types, and attributes. The method involves generating a structured report that includes a detailed table summarizing variable information. This table contains multiple columns that categorize and describe each variable. The first column lists the variable name, while the second column specifies the source file where the variable is defined. The third column identifies the specific component or module within the source file that contains the variable. The fourth column indicates the variable type, such as integer, string, or custom data type. The fifth column provides additional attributes of the variable, such as access modifiers (e.g., public, private) or other metadata. The sixth column references the exact lines of source code where the variable is used, allowing developers to quickly locate its occurrences. This structured approach enables developers to systematically track variable usage, dependencies, and properties, improving code maintainability and debugging efficiency. The method is particularly useful in large-scale software development environments where understanding variable relationships is critical.
15. The method of claim 10, wherein the report includes an eighth section providing a high-level summary overview of the data coupling coverage of the source file and a ninth section providing the source code of the source file associated with the first table and the second table.
This invention relates to data coupling analysis in software systems, specifically improving the visualization and reporting of data dependencies between source code files. The problem addressed is the lack of comprehensive, structured reporting tools that clearly present data coupling relationships, making it difficult for developers to understand and manage interdependencies in large codebases. The method generates a detailed report that includes multiple sections analyzing data coupling coverage. The report features a high-level summary overview section that provides a concise representation of the data coupling relationships between a source file and other components. Additionally, the report includes a section displaying the actual source code of the analyzed file, alongside references to related data structures or tables. This allows developers to directly correlate the code with its coupling metrics, enhancing traceability and maintainability. The analysis involves identifying and mapping data dependencies between the source file and other system components, such as tables or databases. The report structure ensures that both high-level insights and granular code-level details are accessible, supporting better decision-making in software design and refactoring. By integrating source code with coupling data, the invention facilitates deeper understanding of how changes in one part of the system may impact other areas.
17. The system of claim 16, wherein the data couples include data couples arising from parameter couples associated with call into and out of components of the source file.
18. The system of claim 16, wherein each of the one or more data couple tests is individually executable.
22. The system of claim 16, wherein the report includes a sixth section having a first table indicating the control couples of the one or more identified control couples that originate from each of the one or more components of the source file and a second table indicating the control couples of the one or more identified control couples where the destination of the control couple is one of the one or more components of the source file.
23. The system of claim 22, wherein the first table and the second table include a first column identifying a call-from point between the one or more identified control couples, a second column identifying a call-to point between the one or more identified control couples, a third column indicating a destination source file the call-to or call-from is to, a fourth column indicating a software code line of the source file where each of the one or more identified control couples are located, and a fifth column indicating a control coverage of the one or more identified control couples based on the dynamic analysis.
24. The system of claim 23, wherein the fourth section includes source code of the source file associated with the first table and the second table.
The system relates to software development tools, specifically for managing and analyzing source code dependencies within a software project. The problem addressed is the difficulty in tracking and visualizing relationships between source files, particularly in large or complex codebases where dependencies are not easily discernible. This system provides a structured way to organize and display these relationships to improve developer productivity and maintainability. The system includes multiple sections that collectively represent different aspects of source code dependencies. A first section displays a graphical representation of the dependencies between source files, allowing developers to visually identify connections. A second section provides a list of source files involved in the dependencies, offering a textual reference. A third section includes metadata about the dependencies, such as timestamps or modification history, to help track changes over time. The fourth section, which is the focus of this claim, contains the actual source code of the source files associated with the dependencies shown in the first and second sections. This allows developers to directly access and review the relevant code while analyzing the dependency graph. By integrating the source code alongside the dependency visualization, the system enables developers to quickly navigate between the graphical representation and the actual code, streamlining the debugging and refactoring process. The system is particularly useful for identifying and resolving dependency conflicts, understanding code structure, and maintaining large-scale software projects.
25. The system of claim 24, wherein the report includes a seventh section having a third table indicating the data couples of the one or more identified data couples that originate from each of the one or more components of the source file and a fourth table indicating the data couples of the one or more identified data couples where the destination of the data couple is one of the one or more components of the source file, the third table and the fourth table being results for one of the one or more tests.
26. The system of claim 25, wherein the seventh section is repeated for each of the executed one or more data couple tests.
27. The system of claim 25, wherein the third table includes a first column identifying the variable of one of the identified one or more data couples, a second column indicating a software code line of the source file where variable is located, a third column identifying a variable type of the variable, a fourth column identifying a parameter of the one or more components coupled to the variable, a fifth column identifying the component containing the identified parameter, a sixth column identifying a source code line where the parameter calls the variable, and a seventh column identifying a component of the source file containing the component.
28. The system of claim 25, wherein the fourth table includes a first column identifying the variable of one of the identified one or more data couples, a second column identifying a destination component of the variable, a third column identifying a source code line of the source file where the variable is called, a fourth column identifying a component of the source file containing the component calling the variable, a fifth column identifying a variable type of the variable, a sixth column identifying a parameter of the one or more components coupled to the variable, and a seventh column identifying a source code line where the parameter is located.
This invention relates to a system for analyzing and tracking variables and their interactions within a software codebase. The system addresses the challenge of managing complex dependencies and relationships between variables, components, and source code lines in large-scale software development, where maintaining traceability and understanding data flow is critical. The system includes a fourth table that organizes detailed metadata about variables and their usage. This table contains seven columns: the first column identifies the variable name from a data couple (a pair of related variables or components). The second column specifies the destination component where the variable is used. The third column records the source code line where the variable is called. The fourth column identifies the component in the source file that contains the calling code. The fifth column categorizes the variable type (e.g., integer, string, object). The sixth column lists parameters of components coupled to the variable, and the seventh column notes the source code line where these parameters are defined. This structured approach enables developers to trace variable usage across the codebase, identify dependencies, and ensure consistency in variable handling. The system helps in debugging, refactoring, and maintaining large software projects by providing a clear, organized view of how variables interact with components and parameters.
29. The system of claim 25, wherein the seventh section includes a fourth table, the fourth table including a first column identifying a variable of the source file, a second column identifying the source file containing the variable, a third column identifying a component within the source file containing the variable, a fourth column identifying a variable type of the variable, a fifth column identifying an attribute of the variable, and a sixth column identifying the source code lines of the source code file in which the variable is used.
The system relates to software analysis and documentation, specifically for tracking and organizing variable information across source code files. The problem addressed is the lack of centralized, structured documentation for variables in large or complex software projects, making maintenance, debugging, and collaboration difficult. The system provides a structured database that organizes variable metadata to improve code understanding and management. The system includes a seventh section containing a fourth table that systematically catalogs variables from source files. The table has six columns: the first column lists the variable name, the second column specifies the source file where the variable is defined, the third column identifies the specific component (e.g., function, class, module) within the file that contains the variable, the fourth column indicates the variable type (e.g., integer, string, object), the fifth column describes attributes or properties of the variable (e.g., scope, visibility, default value), and the sixth column references the source code lines where the variable is used. This structured approach allows developers to quickly locate and understand variable usage, dependencies, and relationships within the codebase, enhancing productivity and reducing errors. The system may also include additional sections for other code elements, such as functions or classes, to provide a comprehensive documentation framework.
30. The system of claim 25, wherein the report includes an eighth section providing a high-level summary overview of the data coupling coverage of the source file and a ninth section providing the source code of the source file associated with the first table and the second table.
Cooperative Patent Classification codes for this invention. Click any code to explore related patents in that topic.
May 2, 2022
October 18, 2022
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.