A low-code application correctness verification method and system based on formal verification

Abstract

The application provides a low-code application correctness verification method and system based on formal verification. The low-code application correctness verification method based on formal verification comprises the following steps: extracting a flow of a low-code application, setting a formal model for the flow of the low-code application; verifying the formal model, determining whether the low-code application meets performance requirements according to a verification result, and when the verification result indicates that the low-code application does not meet the performance requirements, performing a performance test on the low-code application to obtain test items that do not meet the performance requirements; extracting the test items that do not meet the performance requirements, and performing performance unqualified grade division on the test items to obtain unqualified grades. The system comprises modules corresponding to the method steps.

Description

Technical Field

[0001] This invention proposes a method and system for verifying the correctness of low-code applications based on formal verification, belonging to the field of verification technology for low-code applications. Background Technology

[0002] Currently, building application systems using low-code platforms presents several challenges, one significant issue being the lack of methods for verifying the correctness of low-code processes. This leads to the following problems:

[0003] High trial-and-error costs: Because there is no effective way to verify the correctness of low-code processes, developers have to rely on trial-and-error to discover problems. This leads to high trial-and-error costs, as problems are only discovered at runtime and may require more time and resources to fix.

[0004] Late bug detection: Without verification mechanisms, problems are often discovered late in the development process. This means that bugs may have already penetrated deep into the application system, requiring more work to resolve and potentially causing project delays.

[0005] Lack of early feedback: Without validation methods, developers cannot obtain feedback early in the application's development process. This means they may discover problems later, at which point resolving them is more costly.

[0006] Potential risks: The low barrier to entry for low-code platforms allows more people to participate in application development, but the lack of validation methods may lead to low-quality applications. For example, issues such as infinite loops, branching errors, and incorrect node usage can result in unstable applications. Summary of the Invention

[0007] This invention provides a method and system for verifying the correctness of low-code applications based on formal verification, in order to solve the above-mentioned problems existing in the prior art. The technical solution adopted is as follows:

[0008] A method for verifying the correctness of low-code applications based on formal verification, the method comprising:

[0009] Extract the process of the low-code application and set a formal model for the process of the low-code application;

[0010] The formal model is verified, and the verification results are used to determine whether the low-code application meets the performance requirements. If the verification results show that the low-code application does not meet the performance requirements, the low-code application is subjected to performance testing to obtain test items that do not meet the performance requirements.

[0011] Extract test items that do not meet performance requirements, and classify the performance failure levels of the test items to obtain the failure level.

[0012] Furthermore, the process of the low-code application is extracted, and a formal model is set for the process of the low-code application, including:

[0013] Retrieve the low-code application to be processed;

[0014] Extract the task processing flow of the low-code application;

[0015] The task processing nodes included in the task processing flow of the low-code application are determined through the task processing flow of the low-code application.

[0016] The task processing logic of the task processing flow is determined by the task processing flow of the low-code application.

[0017] A formal model corresponding to the task processing flow is set up using the task processing nodes and task processing logic contained in the task processing flow.

[0018] The formal model can be any one of directed graph, state machine, and Petri net.

[0019] Furthermore, the formal model is validated, and based on the validation results, it is determined whether the low-code application meets the performance requirements. If the validation results indicate that the low-code application does not meet the performance requirements, performance testing is performed on the low-code application to obtain the test items that do not meet the performance requirements, including:

[0020] Retrieve verification tools from the tool library, including SPIN, NuSMV, or other formal verification tools;

[0021] The formal model is validated using a validation tool to obtain validation results;

[0022] When the verification result shows that the current low-code application has been successfully verified, it indicates that the low-code application meets the performance requirements.

[0023] When the verification result shows that the current low-code application fails the verification, it indicates that the low-code application does not meet the performance requirements.

[0024] When the verification result indicates that the current low-code application fails verification, a performance test is performed on the low-code application to obtain the test items that cause the low-code application to fail to meet the performance requirements.

[0025] Furthermore, when the verification result indicates that the current low-code application verification fails, performance testing is performed on the low-code application to obtain the test items that cause the low-code application to fail to meet performance requirements, including:

[0026] Define test items for the performance requirements of low-code applications, wherein the test items for the performance requirements include response time, throughput, and resource utilization;

[0027] Generate a test plan based on the performance requirements of the low-code application;

[0028] The test environment for the performance test was simulated and adjusted to resemble the production environment.

[0029] Performance tests were conducted in a simulated and adjusted production environment according to the generated test plan to obtain the test parameters corresponding to the response time, throughput, and resource utilization.

[0030] The test parameters corresponding to response time, throughput, and resource utilization are compared with the preset parameter thresholds corresponding to response time, throughput, and resource utilization, respectively, to obtain the comparison results;

[0031] Extract the performance requirements from the comparison results that do not meet the parameter threshold requirements;

[0032] Report the items in the performance requirements that do not meet the parameter threshold requirements in the comparison results.

[0033] Furthermore, test items that do not meet performance requirements are extracted, and performance failure levels are categorized for each test item to obtain failure levels, including:

[0034] Extract test items that do not meet performance requirements;

[0035] Based on the relationship between the detection values ​​of test items that do not meet performance requirements and preset parameter thresholds, evaluation parameters for test items that do not meet performance requirements are obtained; wherein, the evaluation parameters are obtained through the following formula:

[0036] E = [1 - (W - W0) / W0 + e] p-1 ]×E0

[0037] Where E represents the evaluation parameter; W represents the detection value corresponding to the test item that does not meet the performance requirements; W0 represents the preset parameter threshold corresponding to the test item that does not meet the performance requirements; e represents a constant; p represents resource utilization; and E0 represents the preset parameter baseline value.

[0038] The evaluation parameters are compared with preset first and second parameter thresholds;

[0039] When the evaluation parameter is lower than the preset first parameter threshold, it indicates that the unqualified level is very poor;

[0040] When the evaluation parameter is not lower than the preset first parameter threshold, but is lower than the preset second parameter threshold, it indicates that the unqualified level is poor.

[0041] When the evaluation parameter is not lower than the preset second parameter threshold, it indicates that the non-compliance level is general.

[0042] A low-code application correctness verification system based on formal verification, the system comprising:

[0043] The formal model setting module is used to extract the process of low-code applications and set a formal model for the process of the low-code applications.

[0044] The verification and performance testing module is used to verify the formal model, determine whether the low-code application meets the performance requirements based on the verification results, and perform performance testing on the low-code application when the verification results show that the low-code application does not meet the performance requirements to obtain test items that do not meet the performance requirements.

[0045] The project extraction and grading module is used to extract test projects that do not meet performance requirements, and to grade the performance of the test projects to obtain the grade of non-compliance.

[0046] Furthermore, the formal model setup module includes:

[0047] The low-code application retrieval module is used to retrieve the low-code application to be processed.

[0048] The task processing flow extraction module is used to extract the task processing flow of the low-code application.

[0049] The task processing node acquisition module is used to determine each task processing node included in the task processing flow of the low-code application.

[0050] The task processing logic determination module is used to determine the task processing logic of the task processing flow based on the task processing flow of the low-code application.

[0051] The formal model forming module is used to set a formal model corresponding to the task processing flow by utilizing the task processing nodes and task processing logic contained in the task processing flow.

[0052] The formal model can be any one of directed graph, state machine, and Petri net.

[0053] Furthermore, the verification and performance testing module includes:

[0054] The verification tool retrieval module is used to retrieve verification tools from the tool library, wherein the verification tools include SPIN, NuSMV, or other formal verification tools;

[0055] The verification result acquisition module is used to verify the formal model using verification tools and obtain verification results;

[0056] The first verification and judgment module is used to indicate that the low-code application meets the performance requirements when the verification result shows that the current low-code application has been successfully verified.

[0057] The second verification and judgment module is used to indicate that the low-code application does not meet the performance requirements when the verification result shows that the current low-code application verification fails.

[0058] The performance test execution module is used to perform performance tests on the low-code application when the verification result shows that the current low-code application verification fails, and to obtain the test items that cause the low-code application to fail to meet the performance requirements.

[0059] Furthermore, the performance test execution module includes:

[0060] The test project customization module is used to define test projects for the performance requirements of low-code applications, wherein the test projects for performance requirements include response time, throughput, and resource utilization.

[0061] The test plan generation module is used to generate a test plan based on the performance requirements of the low-code application.

[0062] The production environment adjustment module is used to simulate and adjust the test environment of the performance test to a production environment.

[0063] The performance testing and test parameter acquisition module is used to perform performance testing in a simulated and adjusted production environment according to the generated test plan, and to obtain the test parameters corresponding to the response time, throughput and resource utilization.

[0064] The comparison result acquisition module is used to compare the test parameters corresponding to the response time, throughput and resource utilization with the preset parameter thresholds corresponding to the response time, throughput and resource utilization respectively, and obtain the comparison results;

[0065] The non-compliance item information acquisition module is used to extract the performance requirements that do not meet the parameter threshold requirements from the comparison results.

[0066] The non-compliant item information reporting module is used to report the performance requirements that do not meet the parameter threshold requirements in the comparison results.

[0067] Furthermore, the project extraction and grading module includes:

[0068] The non-compliance test item extraction module is used to extract test items that do not meet performance requirements;

[0069] The evaluation parameter acquisition module is used to acquire evaluation parameters for test items that do not meet performance requirements based on the relationship between the detection values ​​corresponding to the test items and preset parameter thresholds; wherein, the evaluation parameters are acquired using the following formula:

[0070] E = [1 - (W - W0) / W0 + e] p-1 ]×E0

[0071] Where E represents the evaluation parameter; W represents the detection value corresponding to the test item that does not meet the performance requirements; W0 represents the preset parameter threshold corresponding to the test item that does not meet the performance requirements; e represents a constant; p represents resource utilization; and E0 represents the preset parameter baseline value.

[0072] An evaluation parameter comparison module is used to compare the evaluation parameters with preset first parameter thresholds and second parameter thresholds;

[0073] The first level classification module is used to indicate that the unqualified level is very poor when the evaluation parameter is lower than the preset first parameter threshold.

[0074] The second-level classification module is used to indicate that the unqualified level is poor when the evaluation parameter is not lower than the preset first parameter threshold, but is lower than the preset second parameter threshold.

[0075] The third-level classification module is used to indicate that the non-compliance level is general when the evaluation parameter is not lower than the preset second parameter threshold.

[0076] Beneficial effects of this invention:

[0077] This invention proposes a method and system for verifying the correctness of low-code applications based on formal verification. Formal verification is used to validate the rationality of the low-code workflow, specifically verifying the correctness and rationality of each node's process. This allows for the early detection of problems in low-code application construction, reducing debugging costs and saving time for developers. Simultaneously, it ensures the quality of low-code applications, helping developers identify and resolve issues early in the application development process, reducing trial-and-error costs, and improving application quality and reliability. In this way, low-code platforms will better meet application development needs, reduce potential risks, and increase productivity. Attached Figure Description

[0078] Figure 1 This is a flowchart of the method described in this invention;

[0079] Figure 2 This is a system block diagram of the system described in this invention. Detailed Implementation

[0080] The preferred embodiments of the present invention will be described below with reference to the accompanying drawings. It should be understood that the preferred embodiments described herein are for illustration and explanation only and are not intended to limit the present invention.

[0081] This invention proposes a low-code application correctness verification method based on formal verification, such as... Figure 1 As shown, the low-code application correctness verification method based on formal verification includes:

[0082] S1. Extract the process of the low-code application and set a formal model for the process of the low-code application;

[0083] S2. Verify the formal model, determine whether the low-code application meets the performance requirements based on the verification results, and when the verification results show that the low-code application does not meet the performance requirements, perform performance testing on the low-code application to obtain test items that do not meet the performance requirements.

[0084] S3. Extract test items that do not meet performance requirements, and classify the performance failure level of the test items to obtain the failure level.

[0085] The working principle of the above technical solution is as follows: Extracting the process of low-code application (S1): First, the system extracts the process of low-code application, which describes the various steps and logic of low-code application.

[0086] Establish a formal model: Establish a formal model for the processes of the low-code application. This model can use mathematical logic, formal specification languages, or other forms of abstract description to explicitly define the behavior and rules of the low-code application.

[0087] Verification of the formal model (S2): The system uses formal methods to verify the formal model. This typically includes techniques such as model checking, symbolic execution, and theorem proving to verify whether the low-code application meets performance requirements and other specified specifications.

[0088] Performance requirement verification: Based on the verification results, the system determines whether the low-code application meets the performance requirements. If the verification results indicate that the low-code application does not meet the performance requirements, the system will further execute performance tests to identify test items that do not meet the performance requirements.

[0089] Performance Non-Compliance Classification (S3): After extracting test items that do not meet performance requirements, the system classifies these items into performance non-compliance levels. This may include assessing the severity of performance issues, classifying problems into different levels to better understand the severity of the problems.

[0090] The effects of the above technical solution are as follows: Improve the correctness of low-code applications: Through formal verification, the system can more accurately verify whether low-code applications meet performance requirements and specified specifications, thereby improving the correctness of low-code applications.

[0091] Early detection of performance issues: Formal verification methods help to detect performance problems in low-code applications early on, rather than waiting until actual runtime.

[0092] Improve development efficiency: By verifying and locating problems in advance, development teams can solve performance issues more efficiently and reduce later fix costs.

[0093] Performance Issue Severity Classification: Classifying performance issues helps to address problems more effectively and prioritize the handling of critical performance issues.

[0094] In summary, the above-described technical solutions in this embodiment can improve the quality, performance, and maintainability of low-code applications, ensuring that they meet performance requirements and specifications.

[0095] One embodiment of the present invention extracts the flow of a low-code application and sets a formal model for the flow of the low-code application, including:

[0096] S101, Retrieve the low-code application to be processed;

[0097] S102. Extract the task processing flow of the low-code application;

[0098] S103. Determine each task processing node included in the task processing flow through the task processing flow of the low-code application.

[0099] S104. Determine the task processing logic of the task processing flow through the task processing flow of the low-code application.

[0100] S105. Using the task processing logic of each task processing node and task processing flow contained in the task processing flow, set up a formal model corresponding to the task processing flow.

[0101] The formal model can be any one of directed graph, state machine, and Petri net.

[0102] The working principle of the above technical solution is as follows: Retrieve the low-code application to be processed (S101): First, the system retrieves the low-code application to be processed, which is the target that needs to be verified for correctness.

[0103] Extracting the task processing flow of the low-code application (S102): The system analyzes the low-code application and extracts the task processing flow from it. These flows describe the tasks in the low-code application and the relationships between them.

[0104] Determine task processing nodes (S103): Based on the extracted task processing flow, the system will determine each task processing node contained in each task processing flow. These nodes are key components of the low-code application.

[0105] Determine the task processing logic (S104): The system will also determine the task processing logic of the task processing flow, that is, the execution order and conditional branches between task nodes.

[0106] Setting up a formal model (S105): Based on the task processing nodes and logic in the task processing flow, the system creates a formal model corresponding to the task processing flow. This formal model can use various representation methods, including directed graphs, state machines, or Petri nets, to accurately describe the behavior and rules of low-code applications.

[0107] The effects of the above technical solution are as follows: Accuracy verification: This method allows the system to perform formal verification of the task processing flow of low-code applications to ensure that they meet design specifications and performance requirements.

[0108] Automated verification: Once the formal model is established, automated verification tools can be used to verify low-code applications, reducing the complexity and error risk of manual verification.

[0109] Improving application quality: By establishing and validating formal models, the quality of low-code applications can be improved, error rates reduced, and their correctness and stability ensured.

[0110] Improve maintainability: Formal models can serve as documentation and references, which helps with subsequent application maintenance and modification.

[0111] In summary, the technical solutions described above in this embodiment allow development teams to more accurately verify the correctness of low-code applications, ensure that they meet performance requirements, and improve application quality and maintainability.

[0112] In one embodiment of the present invention, the formal model is verified, and based on the verification results, it is determined whether the low-code application meets the performance requirements. If the verification results indicate that the low-code application does not meet the performance requirements, performance testing is performed on the low-code application to obtain test items that do not meet the performance requirements, including:

[0113] S201. Retrieve a verification tool from the tool library, wherein the verification tool includes SPIN, NuSMV, or other formal verification tools;

[0114] S202. Verify the formal model using a verification tool and obtain the verification results;

[0115] S203. When the verification result shows that the current low-code application has been successfully verified, it indicates that the low-code application meets the performance requirements.

[0116] S204. When the verification result shows that the current low-code application verification fails, it indicates that the low-code application does not meet the performance requirements.

[0117] S205. When the verification result indicates that the current low-code application verification fails, a performance test is performed on the low-code application to obtain the test items that cause the low-code application to fail to meet the performance requirements.

[0118] The working principle of the above technical solution is as follows: Selecting a verification tool (S201): First, select an appropriate verification tool from the tool library. These tools can be used to verify the formal model. Common verification tools include SPIN, NuSMV, or other formal verification tools.

[0119] Formal Model Validation (S202): Validate the previously built formal model using the selected validation tool. This process aims to check whether the low-code application meets performance requirements. The validation tool analyzes the model and looks for potential errors or violations of performance specifications.

[0120] Verification Result Analysis (S203 and S204): Based on the output of the verification tool, two possible verification results can be obtained. If the verification is successful, it means that the low-code application meets the performance requirements and no further testing is needed. If the verification fails, it means that the low-code application does not meet the performance requirements.

[0121] Performance Testing (S205): When verification results indicate that a low-code application does not meet performance requirements, performance testing is necessary to determine the specific reasons why the low-code application fails to meet performance requirements. Performance testing is a detailed test targeting performance bottlenecks or problems. It can identify performance bottlenecks or defects in a low-code application and provide information on how to improve performance.

[0122] The effects of the above technical solution are as follows: Performance requirement satisfaction: Through formal verification and performance testing, it can be clearly determined whether the low-code application meets the performance requirements. This helps ensure that the application can meet the user's performance expectations in actual deployment.

[0123] Error detection: Formal verification can help detect performance issues in low-code applications, identify and correct potential errors in advance, and reduce the cost of later fixes.

[0124] Performance Improvement: Performance testing can identify performance bottlenecks and provide the development team with specific directions and suggestions for performance improvement.

[0125] Maintainability: This process allows development teams to maintain and improve low-code applications to ensure their performance continues to meet requirements.

[0126] In summary, the technical solution described above in this embodiment allows the development team to fully understand the performance of low-code applications, ensure that they meet performance requirements, and promptly identify and fix potential problems.

[0127] In one embodiment of the present invention, when the verification result indicates that the current low-code application verification fails, performance testing is performed on the low-code application to obtain the test items that cause the low-code application to fail to meet performance requirements, including:

[0128] S2051. Define test items for the performance requirements of low-code applications, wherein the test items for the performance requirements include response time, throughput, and resource utilization.

[0129] S2052. Generate a test plan based on the performance requirements of the low-code application;

[0130] S2053. The test environment for the performance test is simulated and adjusted to the production environment;

[0131] S2054. Perform performance testing in a simulated and adjusted production environment according to the generated test plan, and obtain the test parameters corresponding to the response time, throughput and resource utilization.

[0132] S2055. Compare the test parameters corresponding to the response time, throughput, and resource utilization rate with the preset parameter thresholds corresponding to the response time, throughput, and resource utilization rate, respectively, and obtain the comparison results.

[0133] S2056. Extract the performance requirements that do not meet the parameter threshold requirements from the comparison results;

[0134] S2057. Report the performance requirements that do not meet the parameter threshold requirements in the comparison results.

[0135] The working principle of the above technical solution is as follows: Define test items for performance requirements (S2051): First, test items for evaluating the performance of low-code applications are defined. These test items typically include response time (the time required for the application to respond to requests), throughput (the number of requests the application can process per second), and resource utilization (the usage of resources such as CPU, memory, and network).

[0136] Generate a test plan (S2052): Develop a test plan that defines the specific process, steps, and metrics for performance testing. This plan includes defining the test environment, test scenarios, and performance metrics settings.

[0137] Simulate production environment (S2053): Adjust the performance test environment to be as similar as possible to the production environment to ensure that the test results reflect the performance under actual use conditions.

[0138] Performance Testing (S2054): Perform performance tests in a simulated production environment according to the test plan. These tests may include performance tests simulating different loads to evaluate the system's performance under varying load conditions.

[0139] Performance Parameter Comparison (S2055): Compare the parameter values ​​obtained from the performance test with preset performance parameter thresholds. If the test parameters exceed or fall below the thresholds, it indicates that the low-code application does not meet the requirements for the corresponding performance metrics.

[0140] Extract performance requirement items that do not meet the parameters (S2056): Extract the performance requirement items that do not meet the parameter threshold requirements from the comparison results. These items usually indicate the performance problem.

[0141] Reporting non-performance requirements (S2057): Reporting test items that do not meet performance requirements enables the development team to identify and resolve performance issues.

[0142] The effects of the above technical solution are: precise problem localization: through performance testing, performance problems in low-code applications can be accurately located, including which performance requirements have not been met.

[0143] Early identification of performance issues: Performance testing can identify and resolve performance issues before low-code applications are deployed to the production environment, reducing failures and performance degradation in production.

[0144] Improve performance: Based on the results of performance testing, the development team can develop measures to improve performance to ensure that low-code applications meet performance requirements.

[0145] Reduce post-repair costs: Early detection of performance issues can reduce repair costs and decrease the time and resources required to address performance problems in production.

[0146] In summary, the technical solution described above in this embodiment allows development teams to check the performance of low-code applications and take swift action when problems arise to ensure that the application meets performance requirements.

[0147] In one embodiment of the present invention, test items that do not meet performance requirements are extracted, and performance failure levels are classified for each test item to obtain a failure level, including:

[0148] S301. Extract test items that do not meet performance requirements;

[0149] S302. Based on the relationship between the detection values ​​corresponding to the test items that do not meet performance requirements and the preset parameter thresholds, obtain the evaluation parameters for the test items that do not meet performance requirements; wherein, the evaluation parameters are obtained through the following formula:

[0150] E = [1 - (W - W0) / W0 + e] p-1 ]×E0

[0151] Where E represents the evaluation parameter; W represents the detection value corresponding to the test item that does not meet the performance requirements; W0 represents the preset parameter threshold corresponding to the test item that does not meet the performance requirements; e represents a constant; p represents resource utilization; and E0 represents the preset parameter baseline value.

[0152] S303. Compare the evaluation parameters with preset first parameter thresholds and second parameter thresholds;

[0153] S304. When the evaluation parameter is lower than the preset first parameter threshold, it indicates that the unqualified level is very poor.

[0154] S305. When the evaluation parameter is not lower than the preset first parameter threshold, but is lower than the preset second parameter threshold, it indicates that the unqualified level is poor.

[0155] S306. When the evaluation parameter is not lower than the preset second parameter threshold, it indicates that the non-compliance level is general.

[0156] The working principle of the above technical solution is as follows: Extract test items that do not meet performance requirements (S301): First, extract those test items that do not meet performance requirements from the performance test results. These items are usually those whose performance indicators exceed or fall below the preset parameter threshold.

[0157] Obtaining Evaluation Parameters (S302): Evaluation parameter E is calculated by comparing the test values ​​(usually actual performance data) of test items that do not meet performance requirements with preset parameter thresholds. Evaluation parameter E is calculated using a formula, where W represents the test value of the test item that does not meet performance requirements, W0 represents the preset parameter threshold, e and p are constants, and E0 represents the preset parameter baseline value.

[0158] Compare the evaluation parameters (S303): Compare the evaluation parameter E with the preset first parameter threshold and second parameter threshold.

[0159] Classify non-compliance levels (S304, S305, S306): Classify non-compliance levels based on the relationship between the value of evaluation parameter E and the preset parameter threshold.

[0160] When the evaluation parameter is lower than the preset first parameter threshold (S304), the non-compliance level is "very poor".

[0161] When the evaluation parameter is not lower than the first parameter threshold, but lower than the second parameter threshold (S305), the non-compliance level is "poor".

[0162] When the evaluation parameter is not lower than the second parameter threshold (S306), the non-compliance level is "general".

[0163] The effect of the above technical solution is as follows: quantitative assessment of performance problems: by calculating the assessment parameter E, the performance problem is transformed from a qualitative problem into a quantitative problem, so as to more accurately measure the degree of performance non-compliance.

[0164] Tiered performance issues: Based on the value of the evaluation parameter E, performance issues are classified into different levels, which helps the development team to better understand and handle the issues.

[0165] Optimize resource allocation: Different failure levels can guide the development team to allocate resources appropriately for performance optimization in order to solve the most pressing problems.

[0166] Improved performance testing and evaluation processes: This approach helps to improve performance testing and evaluation processes, making them more quantifiable and repeatable, thereby increasing the efficiency of identifying and handling performance issues.

[0167] In summary, the above-described technical solution of this embodiment allows for a systematic determination of performance failure levels, enabling a better understanding of the severity of performance problems and the implementation of appropriate measures to improve the performance of low-code applications.

[0168] This invention proposes a low-code application correctness verification system based on formal verification, such as... Figure 2 As shown, the low-code application correctness verification system based on formal verification includes:

[0169] The formal model setting module is used to extract the process of low-code applications and set a formal model for the process of the low-code applications.

[0170] The verification and performance testing module is used to verify the formal model, determine whether the low-code application meets the performance requirements based on the verification results, and perform performance testing on the low-code application when the verification results show that the low-code application does not meet the performance requirements to obtain test items that do not meet the performance requirements.

[0171] The project extraction and grading module is used to extract test projects that do not meet performance requirements, and to grade the performance of the test projects to obtain the grade of non-compliance.

[0172] The working principle of the above technical solution is as follows: Extracting the process of low-code applications: First, the system extracts the process of low-code applications, which describes the various steps and logic of the low-code applications.

[0173] Establish a formal model: Establish a formal model for the processes of the low-code application. This model can use mathematical logic, formal specification languages, or other forms of abstract description to explicitly define the behavior and rules of the low-code application.

[0174] Formal model verification: The system uses formal methods to verify the formal model. This typically includes techniques such as model checking, symbolic execution, and theorem proving to verify whether the low-code application meets performance requirements and other specified specifications.

[0175] Performance requirement verification: Based on the verification results, the system determines whether the low-code application meets the performance requirements. If the verification results indicate that the low-code application does not meet the performance requirements, the system will further execute performance tests to identify test items that do not meet the performance requirements.

[0176] Performance Failure Level Classification: After extracting test items that do not meet performance requirements, the system classifies these items into performance failure levels. This may include assessing the severity of the performance issues, categorizing problems into different levels to better understand the severity of the problems.

[0177] The effects of the above technical solution are as follows: Improve the correctness of low-code applications: Through formal verification, the system can more accurately verify whether low-code applications meet performance requirements and specified specifications, thereby improving the correctness of low-code applications.

[0178] Early detection of performance issues: Formal verification methods help to detect performance problems in low-code applications early on, rather than waiting until actual runtime.

[0179] Improve development efficiency: By verifying and locating problems in advance, development teams can solve performance issues more efficiently and reduce later fix costs.

[0180] Performance Issue Severity Classification: Classifying performance issues helps to address problems more effectively and prioritize the handling of critical performance issues.

[0181] In summary, the above-described technical solutions in this embodiment can improve the quality, performance, and maintainability of low-code applications, ensuring that they meet performance requirements and specifications.

[0182] In one embodiment of the present invention, the formal model setting module includes:

[0183] The low-code application retrieval module is used to retrieve the low-code application to be processed.

[0184] The task processing flow extraction module is used to extract the task processing flow of the low-code application.

[0185] The task processing node acquisition module is used to determine each task processing node included in the task processing flow of the low-code application.

[0186] The task processing logic determination module is used to determine the task processing logic of the task processing flow based on the task processing flow of the low-code application.

[0187] The formal model forming module is used to set a formal model corresponding to the task processing flow by utilizing the task processing nodes and task processing logic contained in the task processing flow.

[0188] The formal model can be any one of directed graph, state machine, and Petri net.

[0189] The working principle of the above technical solution is as follows: Retrieve the low-code application to be processed: First, the system obtains the low-code application to be processed, which is the target that needs to be verified for correctness.

[0190] Extracting task processing flows from low-code applications: The system analyzes low-code applications and extracts task processing flows from them. These flows describe the tasks in the low-code application and the relationships between them.

[0191] Identify task processing nodes: Based on the extracted task processing flow, the system will identify each task processing node contained in each task processing flow. These nodes are key components of the low-code application.

[0192] Determine the task processing logic: The system will also determine the task processing logic of the task processing flow, that is, the execution order and conditional branches between task nodes.

[0193] Setting up a formal model: Based on the task processing nodes and logic in the task processing flow, the system creates a formal model corresponding to the task processing flow. This formal model can use various representation methods, including directed graphs, state machines, or Petri nets, to accurately describe the behavior and rules of low-code applications.

[0194] The effects of the above technical solution are as follows: Accuracy verification: This method allows the system to perform formal verification of the task processing flow of low-code applications to ensure that they meet design specifications and performance requirements.

[0195] Automated verification: Once the formal model is established, automated verification tools can be used to verify low-code applications, reducing the complexity and error risk of manual verification.

[0196] Improving application quality: By establishing and validating formal models, the quality of low-code applications can be improved, error rates reduced, and their correctness and stability ensured.

[0197] Improve maintainability: Formal models can serve as documentation and references, which helps with subsequent application maintenance and modification.

[0198] In summary, the technical solutions described above in this embodiment allow development teams to more accurately verify the correctness of low-code applications, ensure that they meet performance requirements, and improve application quality and maintainability.

[0199] In one embodiment of the present invention, the verification and performance testing module includes:

[0200] The verification tool retrieval module is used to retrieve verification tools from the tool library, wherein the verification tools include SPIN, NuSMV, or other formal verification tools;

[0201] The verification result acquisition module is used to verify the formal model using verification tools and obtain verification results;

[0202] The first verification and judgment module is used to indicate that the low-code application meets the performance requirements when the verification result shows that the current low-code application has been successfully verified.

[0203] The second verification and judgment module is used to indicate that the low-code application does not meet the performance requirements when the verification result shows that the current low-code application verification fails.

[0204] The performance test execution module is used to perform performance tests on the low-code application when the verification result shows that the current low-code application verification fails, and to obtain the test items that cause the low-code application to fail to meet the performance requirements.

[0205] The working principle of the above technical solution is as follows: Selecting verification tools: First, select appropriate verification tools from the tool library. These tools can be used to verify the formal model. Common verification tools include SPIN, NuSMV, or other formal verification tools.

[0206] Formal Model Validation: Validate the previously built formal model using the selected validation tool. This process aims to check whether the low-code application meets performance requirements. The validation tool analyzes the model and looks for potential errors or violations of performance specifications.

[0207] Verification Result Analysis: Based on the output of the verification tool, two possible verification results can be obtained. If the verification is successful, it means that the low-code application meets the performance requirements and no further testing is needed. If the verification fails, it means that the low-code application does not meet the performance requirements.

[0208] Performance testing: When verification results indicate that a low-code application does not meet performance requirements, performance testing is necessary to determine the specific reasons why the low-code application fails to meet performance requirements. Performance testing is a detailed test targeting performance bottlenecks or problems. It can identify performance bottlenecks or defects in a low-code application and provide information on how to improve performance.

[0209] The effects of the above technical solution are as follows: Performance requirement satisfaction: Through formal verification and performance testing, it can be clearly determined whether the low-code application meets the performance requirements. This helps ensure that the application can meet the user's performance expectations in actual deployment.

[0210] Error detection: Formal verification can help detect performance issues in low-code applications, identify and correct potential errors in advance, and reduce the cost of later fixes.

[0211] Performance Improvement: Performance testing can identify performance bottlenecks and provide the development team with specific directions and suggestions for performance improvement.

[0212] Maintainability: This process allows development teams to maintain and improve low-code applications to ensure their performance continues to meet requirements.

[0213] In summary, the technical solution described above in this embodiment allows the development team to fully understand the performance of low-code applications, ensure that they meet performance requirements, and promptly identify and fix potential problems.

[0214] In one embodiment of the present invention, the performance test execution module includes:

[0215] The test project customization module is used to define test projects for the performance requirements of low-code applications, wherein the test projects for performance requirements include response time, throughput, and resource utilization.

[0216] The test plan generation module is used to generate a test plan based on the performance requirements of the low-code application.

[0217] The production environment adjustment module is used to simulate and adjust the test environment of the performance test to a production environment.

[0218] The performance testing and test parameter acquisition module is used to perform performance testing in a simulated and adjusted production environment according to the generated test plan, and to obtain the test parameters corresponding to the response time, throughput and resource utilization.

[0219] The comparison result acquisition module is used to compare the test parameters corresponding to the response time, throughput and resource utilization with the preset parameter thresholds corresponding to the response time, throughput and resource utilization respectively, and obtain the comparison results;

[0220] The non-compliance item information acquisition module is used to extract the performance requirements that do not meet the parameter threshold requirements from the comparison results.

[0221] The non-compliant item information reporting module is used to report the performance requirements that do not meet the parameter threshold requirements in the comparison results.

[0222] The working principle of the above technical solution is as follows: First, test items for evaluating the performance of low-code applications are defined. These test items typically include response time (the time required for the application to respond to requests), throughput (the number of requests the application can process per second), and resource utilization (the usage of resources such as CPU, memory, and network).

[0223] Generate test plans: Develop test plans that define the specific processes, steps, and metrics for performance testing. These plans include defining the test environment, test scenarios, and performance metrics settings.

[0224] Simulate production environment: Adjust the performance test environment to be as similar as possible to the production environment to ensure that the test results reflect the performance under real-world usage conditions.

[0225] Performance testing: Performance tests are performed in a simulated production environment according to the test plan. These tests may include performance tests simulating different loads to evaluate the system's performance under varying load conditions.

[0226] Performance Parameter Comparison: The parameter values ​​obtained from performance testing are compared with preset performance parameter thresholds. If the test parameters exceed or fall below the thresholds, it indicates that the low-code application does not meet the requirements for the corresponding performance metrics.

[0227] Extract performance requirements that do not meet the parameters: Extract performance requirements that do not meet the parameter threshold requirements from the comparison results. These items usually indicate the performance problems.

[0228] Report projects that do not meet performance requirements: Report test projects that do not meet performance requirements so that the development team can identify and resolve performance issues.

[0229] The effects of the above technical solution are: precise problem localization: through performance testing, performance problems in low-code applications can be accurately located, including which performance requirements have not been met.

[0230] Early identification of performance issues: Performance testing can identify and resolve performance issues before low-code applications are deployed to the production environment, reducing failures and performance degradation in production.

[0231] Improve performance: Based on the results of performance testing, the development team can develop measures to improve performance to ensure that low-code applications meet performance requirements.

[0232] Reduce post-repair costs: Early detection of performance issues can reduce repair costs and decrease the time and resources required to address performance problems in production.

[0233] In summary, the technical solution described above in this embodiment allows development teams to check the performance of low-code applications and take swift action when problems arise to ensure that the application meets performance requirements.

[0234] In one embodiment of the present invention, the project extraction and level classification module includes:

[0235] The non-compliance test item extraction module is used to extract test items that do not meet performance requirements;

[0236] The evaluation parameter acquisition module is used to acquire evaluation parameters for test items that do not meet performance requirements based on the relationship between the detection values ​​corresponding to the test items and preset parameter thresholds; wherein, the evaluation parameters are acquired using the following formula:

[0237] E = [1 - (W - W0) / W0 + e] p-1 ]×E0

[0238] Where E represents the evaluation parameter; W represents the detection value corresponding to the test item that does not meet the performance requirements; W0 represents the preset parameter threshold corresponding to the test item that does not meet the performance requirements; e represents a constant; p represents resource utilization; and E0 represents the preset parameter baseline value.

[0239] An evaluation parameter comparison module is used to compare the evaluation parameters with preset first parameter thresholds and second parameter thresholds;

[0240] The first level classification module is used to indicate that the unqualified level is very poor when the evaluation parameter is lower than the preset first parameter threshold.

[0241] The second-level classification module is used to indicate that the unqualified level is poor when the evaluation parameter is not lower than the preset first parameter threshold, but is lower than the preset second parameter threshold.

[0242] The third-level classification module is used to indicate that the non-compliance level is general when the evaluation parameter is not lower than the preset second parameter threshold.

[0243] The working principle of the above technical solution is as follows: Extract test items that do not meet performance requirements: First, extract those test items that do not meet performance requirements from the performance test results. These items are usually those whose performance indicators exceed or fall below the preset parameter threshold.

[0244] Obtaining Evaluation Parameters: The evaluation parameter E is calculated by comparing the test values ​​(usually actual performance data) of test items that do not meet performance requirements with preset parameter thresholds. Evaluation parameter E is calculated using a formula, where W represents the test value of the test item that does not meet performance requirements, W0 represents the preset parameter threshold, e and p are constants, and E0 represents the preset parameter baseline value.

[0245] Compare the evaluation parameters: Compare the evaluation parameter E with the preset first parameter threshold and second parameter threshold.

[0246] Classification of non-compliance levels: Based on the relationship between the value of evaluation parameter E and the preset parameter threshold, non-compliance levels are classified.

[0247] When the evaluation parameter is lower than the preset first parameter threshold, the non-compliance level is "very poor".

[0248] When the evaluation parameter is not lower than the first parameter threshold, but lower than the second parameter threshold, the non-compliance level is "poor".

[0249] When the evaluation parameter is not lower than the threshold of the second parameter, the non-compliance level is "average".

[0250] The effect of the above technical solution is as follows: quantitative assessment of performance problems: by calculating the assessment parameter E, the performance problem is transformed from a qualitative problem into a quantitative problem, so as to more accurately measure the degree of performance non-compliance.

[0251] Tiered performance issues: Based on the value of the evaluation parameter E, performance issues are classified into different levels, which helps the development team to better understand and handle the issues.

[0252] Optimize resource allocation: Different failure levels can guide the development team to allocate resources appropriately for performance optimization in order to solve the most pressing problems.

[0253] Improved performance testing and evaluation processes: This approach helps to improve performance testing and evaluation processes, making them more quantifiable and repeatable, thereby increasing the efficiency of identifying and handling performance issues.

[0254] In summary, the above-described technical solution of this embodiment allows for a systematic determination of performance failure levels, enabling a better understanding of the severity of performance problems and the implementation of appropriate measures to improve the performance of low-code applications.

[0255] Obviously, those skilled in the art can make various modifications and variations to this invention without departing from its spirit and scope. Therefore, if these modifications and variations fall within the scope of the claims of this invention and their equivalents, this invention also intends to include these modifications and variations.

Claims

1. A method for verifying the correctness of low-code applications based on formal verification, characterized in that, The low-code application correctness verification method based on formal verification includes: Extract the process of the low-code application and set a formal model for the process of the low-code application; The formal model is verified, and the verification results are used to determine whether the low-code application meets the performance requirements. If the verification results show that the low-code application does not meet the performance requirements, the low-code application is subjected to performance testing to obtain test items that do not meet the performance requirements. Extract test items that do not meet performance requirements, and classify the performance failure levels of these test items to obtain the non-compliance scores. Grades, including: Extract test items that do not meet performance requirements; Based on the relationship between the detection values ​​of test items that do not meet performance requirements and preset parameter thresholds, evaluation parameters for test items that do not meet performance requirements are obtained; wherein, the evaluation parameters are obtained through the following formula: E=[1-(W-W0) / W0+e p-1 ]×E0 Where E represents the evaluation parameter; W represents the detection value corresponding to the test item that does not meet the performance requirements; W0 represents the preset parameter threshold corresponding to the test item that does not meet the performance requirements; e represents a constant; p represents resource utilization; and E0 represents the preset parameter baseline value. The evaluation parameters are compared with preset first and second parameter thresholds; When the evaluation parameter is lower than the preset first parameter threshold, it indicates that the unqualified level is very poor; When the evaluation parameter is not lower than the preset first parameter threshold, but is lower than the preset second parameter threshold, it indicates that the unqualified level is poor. When the evaluation parameter is not lower than the preset second parameter threshold, it indicates that the non-compliance level is general.

2. The low-code application correctness verification method based on formal verification according to claim 1, characterized in that, Extract the workflow of a low-code application, and establish a formal model for the workflow of the low-code application, including: Retrieve the low-code application to be processed; Extract the task processing flow of the low-code application; The task processing nodes included in the task processing flow of the low-code application are determined through the task processing flow of the low-code application. The task processing logic of the task processing flow is determined by the task processing flow of the low-code application. A formal model corresponding to the task processing flow is set up using the task processing nodes and task processing logic contained in the task processing flow. The formal model can be any one of directed graph, state machine, and Petri net.

3. The low-code application correctness verification method based on formal verification according to claim 1, characterized in that, The formal model is validated, and based on the validation results, it is determined whether the low-code application meets the performance requirements. If the validation results indicate that the low-code application does not meet the performance requirements, performance testing is performed on the low-code application to obtain the test items that do not meet the performance requirements, including: Retrieve the verification tool from the tool library; The formal model is validated using a validation tool to obtain validation results; When the verification result shows that the current low-code application has been successfully verified, it indicates that the low-code application meets the performance requirements. When the verification result shows that the current low-code application fails the verification, it indicates that the low-code application does not meet the performance requirements. When the verification result indicates that the current low-code application fails verification, a performance test is performed on the low-code application to obtain the test items that cause the low-code application to fail to meet the performance requirements.

4. The low-code application correctness verification method based on formal verification according to claim 3, characterized in that, When the verification result indicates that the current low-code application fails verification, performance testing is performed on the low-code application to identify the test items that cause the low-code application to fail to meet performance requirements, including: Define test items for the performance requirements of low-code applications, wherein the test items for the performance requirements include response time, throughput, and resource utilization; Generate a test plan based on the performance requirements of the low-code application; The test environment for the performance test was simulated and adjusted to resemble the production environment. Performance tests were conducted in a simulated and adjusted production environment according to the generated test plan to obtain the test parameters corresponding to the response time, throughput, and resource utilization. The test parameters corresponding to response time, throughput, and resource utilization are compared with the preset parameter thresholds corresponding to response time, throughput, and resource utilization, respectively, to obtain the comparison results; Extract the performance requirements from the comparison results that do not meet the parameter threshold requirements; Report the items in the performance requirements that do not meet the parameter threshold requirements in the comparison results.

5. A low-code application correctness verification system based on formal verification, characterized in that, The low-code application correctness verification system based on formal verification includes: The formal model setting module is used to extract the process of low-code applications and set a formal model for the process of the low-code applications. The verification and performance testing module is used to verify the formal model, determine whether the low-code application meets the performance requirements based on the verification results, and perform performance testing on the low-code application when the verification results show that the low-code application does not meet the performance requirements to obtain test items that do not meet the performance requirements. The project extraction and grading module is used to extract test projects that do not meet performance requirements, and to categorize the performance of the test projects into unqualified grades to obtain the unqualified grades. The project extraction and grading module includes: The non-compliance test item extraction module is used to extract test items that do not meet performance requirements; The evaluation parameter acquisition module is used to acquire evaluation parameters for test items that do not meet performance requirements based on the relationship between the detection values ​​corresponding to the test items and preset parameter thresholds; wherein, the evaluation parameters are acquired using the following formula: E=[1-(W-W0) / W0+e p-1 ]×E0 Where E represents the evaluation parameter; W represents the detection value corresponding to the test item that does not meet the performance requirements; W0 represents the preset parameter threshold corresponding to the test item that does not meet the performance requirements; e represents a constant; p represents resource utilization; and E0 represents the preset parameter baseline value. An evaluation parameter comparison module is used to compare the evaluation parameters with preset first parameter thresholds and second parameter thresholds; The first level classification module is used to indicate that the unqualified level is very poor when the evaluation parameter is lower than the preset first parameter threshold. The second-level classification module is used to indicate that the unqualified level is poor when the evaluation parameter is not lower than the preset first parameter threshold, but is lower than the preset second parameter threshold. The third-level classification module is used to indicate that the non-compliance level is general when the evaluation parameter is not lower than the preset second parameter threshold.

6. The low-code application correctness verification system based on formal verification according to claim 5, characterized in that, The formal model setup module includes: The low-code application retrieval module is used to retrieve the low-code application to be processed. The task processing flow extraction module is used to extract the task processing flow of the low-code application. The task processing node acquisition module is used to determine each task processing node included in the task processing flow of the low-code application. The task processing logic determination module is used to determine the task processing logic of the task processing flow based on the task processing flow of the low-code application. The formal model forming module is used to set a formal model corresponding to the task processing flow by utilizing the task processing nodes and task processing logic contained in the task processing flow. The formal model can be any one of directed graph, state machine, and Petri net.

7. The low-code application correctness verification system based on formal verification according to claim 5, characterized in that, The verification and performance testing module includes: The verification tool retrieval module is used to retrieve verification tools from the tool library; The verification result acquisition module is used to verify the formal model using verification tools and obtain verification results; The first verification and judgment module is used to indicate that the low-code application meets the performance requirements when the verification result shows that the current low-code application has been successfully verified. The second verification and judgment module is used to indicate that the low-code application does not meet the performance requirements when the verification result shows that the current low-code application verification fails. The performance test execution module is used to perform performance tests on the low-code application when the verification result shows that the current low-code application verification fails, and to obtain the test items that cause the low-code application to fail to meet the performance requirements.

8. The low-code application correctness verification system based on formal verification according to claim 7, characterized in that, The performance test execution module includes: The test project customization module is used to define test projects for the performance requirements of low-code applications, wherein the test projects for performance requirements include response time, throughput, and resource utilization. The test plan generation module is used to generate a test plan based on the performance requirements of the low-code application. The production environment adjustment module is used to simulate and adjust the test environment of the performance test to a production environment. The performance testing and test parameter acquisition module is used to perform performance testing in a simulated and adjusted production environment according to the generated test plan, and to obtain the test parameters corresponding to the response time, throughput and resource utilization. The comparison result acquisition module is used to compare the test parameters corresponding to the response time, throughput and resource utilization with the preset parameter thresholds corresponding to the response time, throughput and resource utilization respectively, and obtain the comparison results; The non-compliance item information acquisition module is used to extract the performance requirements that do not meet the parameter threshold requirements from the comparison results. The non-compliant item information reporting module is used to report the performance requirements that do not meet the parameter threshold requirements in the comparison results.

Images