Method and device for supporting automatic testing of parallel grid generation software

Abstract

The invention discloses a method and device for supporting automatic testing of parallel grid generation software, and relates to a large-scale grid quality evaluation and testing process automation technology. The method comprises the following steps: deploying a master control node, constructing nodes and parallel test nodes, establishing a connection relationship between the nodes, and constructing a schedulable test basic environment; obtaining a structured configuration file comprising a compiling task, a testing task and a quality analysis parameter according to the testing basic environment; when the master control node detects a preset event, a compiling task is distributed to the construction node based on the configuration file, and a corresponding construction product is generated; after compilation is completed, a construction product is distributed to each parallel test node; each test node executes a test task based on the construction product to generate a test product grid; and finally, performing quality analysis on the test product grid, automatically generating a test report, and realizing full automation and parallel processing of the test process.

Description

Technical Field

[0001] The present application relates to the technical field of software testing and quality analysis, and in particular to a method and apparatus for supporting automated testing of parallel grid generation software. Background Art

[0002] In the field of software testing and automated verification, as system scale and application complexity increase, traditional serial testing and verification processes are no longer able to meet the requirements for efficient and accurate testing. This is especially true in scenarios requiring large-scale data processing, complex modeling verification, and grid generation testing. The serial execution model suffers from long execution cycles, low resource utilization, and high error rates, severely hindering the efficiency of software system development and delivery.

[0003] To improve testing efficiency, some test systems have begun to introduce automated build and test processes, coupled with a certain degree of parallel scheduling. However, existing technologies still have the following problems in practical applications: (1) Lack of a flexible and scalable node scheduling system. In the existing automated testing framework, the node deployment method is fixed and the scheduling granularity is coarse, making it difficult to perform targeted allocation based on different task types (such as compilation tasks, testing tasks, and quality analysis tasks). This leads to insufficient resource utilization and severe task congestion.

[0004] (2) The degree of automation in the compilation and testing processes is limited. Traditional systems often rely on a large amount of manual script maintenance and configuration file management when executing the compilation, testing, and quality analysis stages. The lack of a unified and structured parameter configuration standard makes it easy to introduce configuration errors, increase maintenance costs, and reduce the automation level of the overall process.

[0005] (3) Lack of efficient artifact management and delivery mechanisms during parallel execution. During the testing process, artifacts and test input data typically need to be transferred and managed between different nodes. Existing methods lack systematic mechanisms for artifact distribution, persistence, and archiving, leading to frequent problems such as data redundancy, transmission delays, and artifact loss, further reducing overall testing efficiency.

[0006] (4) Grid testing and quality analysis are separated and require a lot of manual intervention. In the test process involving grid structure generation and analysis, existing systems often require manual intervention to complete the extraction, analysis, and report generation of the test product grid. The lack of an integrated processing mechanism from testing to quality assessment increases labor costs and the probability of error.

[0007] Therefore, there is an urgent need for a testing method that supports parallelism, can automate the entire process of construction, testing, and quality analysis, and has the ability to efficiently manage products and generate reports, so as to improve the automation level, resource utilization and overall execution efficiency of system testing, and meet the actual needs of rapid delivery of large-scale and complex systems. Summary of the Invention

[0008] In view of this, an embodiment of the present invention provides a method and apparatus for supporting automated testing of parallel grid generation software to solve the problems existing in the background technology.

[0009] According to a first aspect of an embodiment of the present application, a method for supporting automated testing of parallel grid generation software is provided, comprising: Deploy master nodes, build nodes, and parallel test nodes, establish connections between nodes, and generate a schedulable test infrastructure environment; According to the test basic environment, obtain the structured configuration parameter files required for compilation tasks, test tasks and quality analysis; According to the structured configuration parameter file, when the master control node detects a preset event, it distributes the compilation task to the construction node to generate a construction product; According to the structured configuration parameter file, after the compilation task is completed, distributing the build product to the parallel test node; executing a test task on the build product on the parallel test node according to the structured configuration parameter file to generate a test product grid; According to the structured configuration parameter file, quality analysis is performed on the test product grid to generate a corresponding test report.

[0010] According to a second aspect of an embodiment of the present application, there is provided an apparatus for supporting automated testing of parallel grid generation software, comprising: The master control node is used to listen to preset events, parse structured configuration parameter files, and distribute compilation tasks to build nodes; receive build product information returned by the build nodes, distribute build products and test tasks to parallel test nodes; receive test product grids and quality analysis reports returned by the parallel test nodes, and realize unified scheduling and coordinated control of the entire automated test process; The build node receives the compilation tasks distributed by the master node, performs the compilation operations according to the structured configuration parameter file, generates the build products, and returns the build products to the master node; Parallel test nodes are used to receive test tasks and build products distributed by the master node, execute test operations according to the structured configuration parameter file, generate a test product grid, perform quality analysis and feed the results back to the master node; The three nodes communicate with each other to generate a schedulable test infrastructure environment and realize collaborative execution and data interaction of each test stage in a local area network or virtual network.

[0011] The technical solutions provided by the embodiments of the present application may have the following beneficial effects: It can be seen from the above embodiments that the present application adopts a three-node collaborative architecture based on a master control node, a build node and a parallel test node, and uniformly defines and drives the compilation, testing and analysis processes through structured configuration parameter files. Therefore, it overcomes the problems of chaotic node collaboration, lack of unified scheduling of task execution, and low efficiency of test data flow in the traditional grid generation software testing process, thereby achieving the technical effect of highly automated testing process, clear task scheduling logic, and traceable construction and testing product processes throughout the entire process.

[0012] It should be understood that the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the present application. BRIEF DESCRIPTION OF THE DRAWINGS

[0013] The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the present application and, together with the description, serve to explain the principles of the present application.

[0014] Figure 1 A flowchart of a method and apparatus for supporting automated testing of parallel grid generation software provided in an embodiment of the present application; Figure 2 The overall system architecture diagram provided for the embodiment of the present application shows the master node, build node, parallel test node and their mutual communication relationship.

[0015] Figure 3 Schematic diagram of the container management platform provided in an embodiment of the present application.

[0016] Figure 4 A schematic diagram of a task triggering event provided in an embodiment of the present application.

[0017] Figure 5 State diagram of the build node and parallel test node provided in the embodiment of the present application.

[0018] Figure 6 A schematic diagram of the virtual network configuration of the master control node provided in an embodiment of the present application.

[0019] Figure 7 A schematic diagram of a virtual network configuration for building nodes provided in an embodiment of the present application.

[0020] Figure 8 A schematic diagram of a construction node connected to a master control node via a virtual network provided in an embodiment of the present application.

[0021] Figure 9 A schematic diagram of the test node virtual network configuration provided in an embodiment of the present application.

[0022] Figure 10 The test node provided in the embodiment of the present application is connected to the master node and the construction node through a virtual network.

[0023] Figure 11 Schematic diagram of the structured configuration parameter file in the construction phase provided in an embodiment of the present application.

[0024] Figure 12 A flowchart of the compilation script for calling a structured configuration parameter file in the construction phase provided in an embodiment of the present application.

[0025] Figure 13 Schematic diagram of product information configuration and product catalog provided for the embodiment of this application.

[0026] Figure 14 Schematic diagram of the structured configuration parameter file for the parallel testing phase provided in an embodiment of the present application.

[0027] Figure 15 A test script flow chart for calling a structured configuration parameter file in the parallel testing phase provided in an embodiment of the present application.

[0028] Figure 16 Schematic diagram of the structured configuration parameter file for the quality analysis phase provided in an embodiment of the present application.

[0029] Figure 17 A flowchart of the master node monitoring and node response construction provided in an embodiment of the present application.

[0030] Figure 18 A task definition diagram is compiled in a structured configuration file provided in an embodiment of the present application.

[0031] Figure 19 A schematic diagram of the process of executing a compilation task by a construction node provided in an embodiment of the present application.

[0032] Figure 20 A schematic diagram of the process of persistent storage and metadata recording of construction products provided in an embodiment of the present application.

[0033] Figure 21 A schematic diagram of a process for executing a product test task and generating a test product grid by a parallel test node provided in an embodiment of the present application.

[0034] Figure 22 This is a screenshot of SFTP mounting a local disk provided in an embodiment of the present application.

[0035] Figure 23A schematic diagram of a grid of test products in VTK format generated and persistently saved by a parallel test node provided in an embodiment of the present application.

[0036] Figure 24 Schematic diagram of the test product mesh quality analysis and test report generation process provided in the embodiment of this application.

[0037] Figure 25 Schematic diagram of grid quality analysis function call and log output provided in an embodiment of the present application.

[0038] Figure 26 Schematic diagram of the quality analysis operation process provided in the embodiment of the present application.

[0039] Figure 27 This is a generated grid quality report diagram provided in an embodiment of the present application.

[0040] Figure 28 A schematic diagram of the deployment of a multi-node test system based on a hybrid communication architecture of virtual switching and physical switching provided in an embodiment of the present application. DETAILED DESCRIPTION

[0041] The method of the present invention is described in detail below with reference to the accompanying drawings and embodiments.

[0042] like Figure 1 As shown, the present invention provides a method and apparatus for supporting automated testing of parallel grid generation software, comprising the following steps: S1: Deploy the master node, build node and parallel test node, establish connections between nodes, and generate a schedulable test infrastructure. The overall system architecture is as follows: Figure 2 As shown, it includes the following sub-steps: S11: On a Linux system, a container management platform is used to deploy a master node operating environment on the master node to support high-availability operation of the scheduling service. The master node is responsible for receiving task trigger events, unifying the scheduling build and test processes, and coordinating the parallel execution of multiple nodes. Specifically, the container management platform refers to a management platform with functions such as container deployment, resource scheduling, node management, and operating environment maintenance. Figure 3 Using a container management platform to deploy the master control service can provide higher maintainability and elastic scalability, and support fault self-recovery mechanisms to achieve high availability and stable operation of the scheduling system.

[0043] Specifically, the task triggering event refers to code submission, branch merging, tag pushing, timed triggering, manual triggering, external system call, etc. Figure 4 shown.

[0044] Specifically, the scheduling service involves the master node dispatching compilation tasks to build nodes and testing tasks to parallel test nodes upon receiving a task trigger event, and coordinating the execution of the corresponding task flows across these nodes. This unified scheduling mechanism simplifies task management and improves overall process collaboration efficiency.

[0045] S12: On the Linux system, a compilation environment is deployed on the build node through the container management platform to support efficient compilation task execution. The build node is responsible for receiving compilation tasks from the master node, executing related build processes, generating build artifacts, and ensuring efficient collaboration and task transmission with other nodes. Specifically, the construction node refers to a virtual machine used for construction operations, and its node status is as follows: Figure 5 As shown in the figure, this node deploys a compilation task execution service running in a container. This service automatically pulls build tasks, executes the compilation process, and produces build results. After deployment, this service registers with the master node by establishing a trusted connection. This allows the master node to automatically issue build instructions based on triggering events and transfer the relevant code and dependencies to the build node for execution. This automatic pull and registration mechanism ensures real-time task response and system scalability.

[0046] S13: On the Linux system, a test environment is deployed in parallel test nodes through the container management platform to support efficient test task execution. The parallel test nodes are responsible for receiving build products from the build nodes and test tasks from the master node, executing the corresponding test processes, and feeding back test reports to the master node. Specifically, the parallel test node refers to a virtual computing node that can independently run the test process, and its node status is as follows: Figure 5 As shown in the figure, a service component is deployed internally that automates test script execution, collects test results, and generates reports. Test nodes load necessary dependency libraries and test tools through a uniformly configured container runtime environment. The introduction of an independent dual-source input mechanism of "build product transmission + parallel test scheduling" ensures high flexibility and independence for test nodes, effectively addressing the issue of excessive build / test coupling in traditional test architectures.

[0047] S14: Configure a virtual network in the LAN environment and establish a connection between the virtual network card in the container and the LAN to ensure that the master node, build node, and parallel test node can interconnect efficiently and securely.

[0048] Specifically, the virtual network configuration includes the master node network configuration, such as the construction node network configuration and the parallel test node network configuration. Figure 5 、 Figure 7 and Figure 9shown.

[0049] Specifically, the interconnection includes building nodes to connect to the master node and parallel test nodes through a virtual network. Figure 8 As shown. The parallel test nodes are connected to the master node and the build node through the virtual network. The parallel test node connectivity is shown in Figure 10 As shown in the figure, virtual networks achieve isolation and control between nodes, ensuring network security while also improving data transmission efficiency between nodes. Virtual network cards, when configured uniformly, can be quickly reused and expanded, eliminating the complex setup and management issues of traditional physical network deployments.

[0050] S2: Based on the test basic environment, obtain the structured configuration parameter files required for compilation tasks, test tasks, and quality analysis, including the following sub-steps: S21: Based on the source code location, dependency information, and compilation options described in the structured configuration parameter file, a compilation script file is pre-written, and a command for calling the compilation script is written in the structured configuration parameter file to complete the automated compilation of the source code; Specifically, the compilation information in the structured configuration parameter file is organized using a hierarchical syntax, which supports defining multiple build targets in the same build process. Figure 11 As shown in the figure, a build task is used as an example. This task specifies the build phase, platform-specific tags, the build script sequence to be executed, and the inherited base build template. By abstracting and encapsulating compilation task parameters into scripts and managing them in structured files, the entire build process can be reproduced, audited, and quickly switched between different build strategies. This also enables manual triggering of build tasks, improving CI automation.

[0051] The build information uses a label mechanism to limit the execution node range of the task, ensuring that the task is only run on nodes that meet specific platform conditions; for example Figure 12 As shown in the figure, the script part lists multiple build pre-processing and core scripts that are executed in sequence to implement the environment preparation and source code building process; through the inheritance mechanism, predefined build behavior templates are introduced, such as build cache path, compilation tool chain configuration, etc., which improves configuration reusability and consistency.

[0052] S22: In the structured configuration parameter file, define the product information that needs to be saved during compilation and testing, such as Figure 13 As shown, it specifically includes the file path, directory path, storage period and target storage location to be saved; Specifically, presetting the product preservation strategy in the parameter file can accurately manage resources, avoid the accumulation of redundant products, and improve the system's storage efficiency and lifecycle management capabilities; at the same time, it is convenient to reuse products in subsequent processes and improve the overall task execution efficiency.

[0053] S23: Define the execution content of the test phase in the structured configuration parameter file, including the path of the test script, the test timeout period, and the handling strategy after the test failure; Specifically, if Figure 14 As shown in the figure, the structured configuration parameter file defines the test task name, execution stage identifier, running environment label, dependent preceding build tasks, and specific test execution script and its parameters for the test phase. The test execution script is as follows: Figure 15 As shown in the figure, this configuration uses structured fields to describe the test execution sequence, target test script path, execution permission settings, and dependencies, enabling the test service to automatically identify the test execution order, target test script path, execution permission settings, and dependencies, supporting automatic scheduling and execution control of the test process. Using structured fields to fully express the context of test tasks improves the system's ability to adapt and control parallelism in complex test processes, making it particularly suitable for test management in multi-stage, cross-platform, or microservice architectures.

[0054] S24: In the structured configuration parameter file, define the execution content of the quality analysis phase, including the name of the quality analysis tool, the path of the analysis script, the analysis parameter configuration, the quality threshold standard, and the name of the generated test report.

[0055] Specifically, in the structured configuration parameter file, Figure 16 As shown, multiple key fields are configured for the quality analysis phase, including: a label field for identifying the task phase, a script path for performing quality analysis, a dependency declaration of the preceding build task, and an execution environment label. Among them, after the analysis script is granted execution permission, it is dispatched by the master node to the target node for execution to perform operations such as code quality inspection, indicator analysis, and quality threshold verification. This configuration also supports the generation of corresponding test reports after the analysis task is completed, and integrates with other modules through a unified naming method, so that the system can automatically summarize quality results and output test documents, thereby improving test coverage and traceability. Decoupling the quality gating standards from the analysis tool configuration and managing them in a structured manner makes quality analysis more configurable and project adaptable; standard unification also helps in the later integration of quality warning and release interception mechanisms in DevOps.

[0056] S3: According to the structured configuration parameter file, when the master control node detects a preset event, it distributes the compilation task to the build node to generate a build product, including the following sub-steps: S31: The master node continuously monitors preset trigger conditions. When an event that meets the trigger conditions is detected, the master node records the event information and prepares to start subsequent tasks. The trigger conditions include source code submission, branch merging, tag creation, or other operations related to version changes. Specifically, monitoring can ensure that the system can respond to code change events in the first time, avoid delays caused by manual triggering or periodic polling, and improve the real-time and agility of the build system.

[0057] Specifically, the master node continuously monitors the trigger source integrated with the version control system. Figure 17 When performing version change-related operations such as source code submission, target branch merging, and tag creation, the system automatically records key information about the event, including the trigger time, committer ID, changed branch, and change summary. The event is used as the basis for subsequent process scheduling to prepare for the execution of corresponding build or test tasks, ensuring that the system can automatically drive downstream processing after the version update.

[0058] S32: The master control node determines the compilation task content to be distributed according to the structured configuration parameter file, including the modules to be compiled and the compilation parameters.

[0059] Specifically, the master node receives Figure 4 and Figure 11 After the trigger event shown in the stage field, the field information related to the compilation stage in the structured configuration parameter file is automatically parsed, including the specified building module identifier, the compilation script path required for the build, the compilation parameters, and the dependency definition. The system extracts the key elements of the compilation task through the parameter parsing process, and constructs a task description object in a unified format as the basis for subsequent task scheduling and distribution, thereby realizing flexible build management in a multi-module and multi-configuration environment. The parsing of build content driven by configuration files helps to modularize the management of different tasks and avoid hard coding. Using structured configuration to automatically parse modules and their parameters to build a unified task object is a module-level scheduling abstraction that is difficult to achieve with traditional pipeline scripts. This method enhances cross-project versatility, reduces script maintenance costs, and improves the standardization level of task scheduling.

[0060] S33: The master control node distributes the corresponding compilation task to the construction node according to the determined compilation task content, so that the construction node can perform the compilation operation later; Specifically, if Figure 18As shown in the figure, after parsing and organizing the compilation task content, the master node selects an available build node based on the build tags or resource constraints specified in the task description. It then uses the scheduling module to send the task instructions, including the build script path, compilation parameters, and execution order, to the target build node. During the distribution process, the master node records the task allocation status and tracks node response to ensure that build tasks are accurately and efficiently distributed and entered into the execution queue, supporting subsequent parallel or sequential compilation processes.

[0061] S34: The build node receives the compilation task distributed by the master node, and performs the compilation operation according to the task content to generate the corresponding build product; Specifically, after receiving the compilation task distributed by the master node according to the structured configuration parameter file, the build node Figure 19 As shown, the system automatically parses the task's to-be-compiled module information, compilation parameters, and dependency descriptions, then invokes the locally configured compilation script or compilation toolchain to compile the corresponding modules one by one. After compilation is complete, the system automatically generates the corresponding build artifacts and records the compilation log and result status to support subsequent artifact archiving, quality assessment, and build traceability verification. Delegating execution authority to build nodes reduces pressure on the master control node, while also supporting parallel builds and improving overall system throughput.

[0062] S35: The construction node persistently saves the generated construction product according to the definition of product saving in the structured configuration parameter file.

[0063] Specifically, after the build node completes the compilation operation and generates the build product, it automatically executes the product persistence process according to the product preservation strategy and path definition preset in the structured configuration parameter file. Figure 20 As shown in the figure, this process includes identifying build files to be archived, categorizing and naming artifacts according to configuration requirements, mapping their paths, and storing them in a designated persistent storage location. Furthermore, the build node will synchronously record and save the path and artifact metadata to facilitate subsequent artifact scheduling, distribution, and retrospective queries, ensuring traceability of the build process and controllability of artifact management. Incorporating artifact management strategies into the configuration system and decoupling them from the build execution logic makes the build process more maintainable and automated, making it suitable for multi-version, multi-environment build archiving needs.

[0064] S4: Distributing the build product to the parallel test nodes according to the structured configuration parameter file after the compilation task is completed, including the following sub-steps: S41: The master control node determines the distribution rules according to the structured configuration parameter file, including the build products to be distributed and their corresponding parallel test nodes; Specifically, the master control node is based on Figure 14 The structured configuration parameter file shown here contains artifact distribution configurations, parsing the build artifacts to be distributed and their corresponding target test nodes. The master control node, based on the current system status, determines the distribution path and parallel delivery strategy for each build artifact, preparing for resource scheduling in the subsequent automated testing phase. This ensures that test nodes receive build artifacts in a timely manner, supporting the concurrent execution of subsequent test tasks and improving overall process efficiency and system responsiveness.

[0065] S42: The master control node distributes the corresponding build product to the parallel test node according to the distribution rule determined in S41; Specifically, the master node distributes the corresponding build products to designated parallel test nodes via network transmission based on the defined distribution rules. During the distribution process, the system supports multi-threading or asynchronous mechanisms to improve transmission efficiency and records the distribution status for tracking and fault retry. This improves the efficiency and stability of data distribution, which is particularly advantageous in high-concurrency and large-scale clusters.

[0066] S43: The parallel test node receives the build product distributed by the master node and prepares for subsequent test operations.

[0067] Specifically, the test node has the ability to automatically prepare after receiving the product (such as path mounting, verification, preprocessing, etc.), which is a key link in realizing the "zero human intervention automated test link" and significantly improves the closed-loop efficiency of the test process.

[0068] S5: According to the structured configuration parameter file, the test task is executed on the parallel test node to generate a test product grid, such as Figure 21 As shown, it includes the following sub-steps: S51: Determine test input content to be used in a test phase according to the structured configuration parameter file, wherein the test input content includes a pre-prepared geometric data file; Specifically, the parallel test nodes are configured according to the paths and credentials defined in the structured configuration parameter file, such as Figure 22 As shown in the figure, by mounting the SFTP file management service provided by the master node, the geometric data files required for testing are obtained as test input, ensuring that the test tasks have complete initial data support. Dynamically loading master node resources through the SFTP mounting mechanism avoids redundant data copying, enhances data sharing capabilities between nodes, and facilitates the unified scheduling and management of large-scale data input.

[0069] S52: Determine test execution rules based on the structured configuration parameter file, such as Figure 14As shown, the test execution rules include test script path, test parameter configuration, test timeout and test failure handling strategy; Specifically, incorporating the post-test failure processing strategy into configuration management can automatically perform operations such as retry, abort, and skip, thereby improving the system's fault tolerance for unexpected test behaviors.

[0070] S53: On the parallel test node, calling the construction product, and executing the test task according to the determined test input content and the determined test execution rule; Specifically, the parallel test nodes invoke the corresponding build artifacts based on the structured configuration parameter files. Combined with pre-determined test inputs and test execution rules, they automatically execute test scripts or commands to complete the test process for the build artifacts. By integrating test execution scripts, parameters, inputs, and artifacts into a structured configuration-driven execution flow, each test node can run independently and automatically, creating a "self-scheduling + self-executing" test micro-unit, significantly enhancing the system's automation level.

[0071] S54: generating a test product grid on the parallel test node according to the test task execution result; Specifically, after completing the test task, the parallel test node automatically generates a test product grid according to the test execution result, and outputs it in the form of a VTK file to represent the spatial data or calculation results generated in the test for subsequent visualization or analysis.

[0072] Specifically, the test node can dynamically generate mesh data in VTK format based on the test results, taking into account the visualization requirements and versatility of scientific computing, meeting the needs of subsequent analysis and processing, and laying the foundation for a closed-loop technology.

[0073] S55: According to the structured configuration parameter file, persistently save the test product grid on the parallel test node.

[0074] Specifically, the parallel test node saves the generated VTK format test product grid to the master node persistently according to the save path and naming rules defined in the structured configuration parameter file, ensuring that the test results are traceable and reusable. Figure 23 The test product mesh is generated in VTK format.

[0075] S6: Perform quality analysis on the test product grid according to the structured configuration parameter file and generate a corresponding test report, such as Figure 24 As shown, it includes the following sub-steps: S61: Determine the index content that needs to be tested in the quality analysis phase according to the structured configuration parameter file, wherein the index content includes an accuracy index and a completeness index; Specifically, the parallel test node parses the indicator content that needs to be tested in the current quality analysis stage according to the quality analysis configuration items preset in the structured configuration parameter file. The indicator content includes accuracy indicators for reflecting the correctness of the data and integrity indicators for evaluating the completeness of the data, providing a basis for subsequent analysis processes.

[0076] S62: Determine quality analysis rules according to the structured configuration parameter file, wherein the quality analysis rules include minimum angle, maximum angle, side length ratio, unit shape regularity, area consistency, and grid connectivity consistency; S63: Loading the test product grid on the parallel test node as object data for quality analysis; S64: performing quality analysis on the loaded test product grid according to the determined quality analysis rules on the parallel test node to obtain test results of various quality indicators; Specifically, the parallel test nodes are based on the quality analysis rules predetermined in the structured configuration parameter file, such as Figure 25 As shown in the figure, the quality analysis operation is performed on the loaded test product mesh item by item, and the actual values ​​of various indicators are automatically calculated, including quality factors such as volume, angle, shape regularity, etc. Figure 26 As shown, the corresponding test results are output as the basic data for subsequent report generation.

[0077] S65: Generate a corresponding test report on the parallel test node according to the test results of each quality indicator.

[0078] Specifically, the test report structure is as follows: Figure 27 As shown in the figure, the quality analysis process is automatically generated, including a mesh optimization operation log, quality assessment data for each stage, and overall performance metrics. The report includes: optimization operation records for the mesh volume-to-edge ratio and dihedral angles, the optimization strategy used (such as flipping, Laplace smoothing, splitting, etc.), the quality analysis results of each round (number of bad elements, minimum quality minQ, average quality avg, and corresponding element ID), angle statistics (minimum angle, maximum angle, average angle, etc.), mesh removal and repair information (such as hole treatment), and final mesh quality metrics, including total time, optimization speed, number of tetrahedrons, memory usage, and generation success indicator.

[0079] refer to Figure 2 , an embodiment of the present invention further provides a device for supporting automated testing of parallel grid generation software, comprising: The master control node is used to listen to preset events, parse structured configuration parameter files, distribute compilation tasks to build nodes, receive build product information returned by the build nodes, distribute build products and test tasks to parallel test nodes, and receive test product grids and quality analysis reports returned by the parallel test nodes, thus achieving unified scheduling and coordinated control of the entire automated testing process; Specifically, the master node is deployed in a physical server environment or a containerized scheduling service environment, and continuously listens for preset trigger events including code submission, branch merging, or tag creation. When an event is captured, it automatically parses the structured configuration parameter file, extracts the task configuration and execution rules, and then calls the scheduling logic to send the compilation task to the build node. After receiving the build product, it completes the task and product synchronization of the parallel test node in combination with the test task configuration, and summarizes the grid data and quality analysis reports fed back by each node after the test is completed, to achieve unified scheduling and closed-loop control across nodes and stages.

[0080] Specifically, it adopts a containerized scheduling service and a parsing mechanism for structured configuration files, which can dynamically trigger and automatically distribute compilation and testing tasks according to preset events, improving the response speed and flexibility of the testing process; thereby achieving the technical effect of reducing manual intervention, improving the degree of automation and multi-node collaboration efficiency, and is conducive to the continuous integration and stable testing of large-scale grid generation software in high-performance computing environments.

[0081] The build node receives the compilation tasks distributed by the master node, performs the compilation operations according to the structured configuration parameter file, generates the build products, and returns the build products to the master node; Specifically, the build node is deployed in a physical server environment or a containerized scheduling service environment, receives the task content distributed by the master node, including the source code path, dependency description and compilation parameters, and automatically calls the preset build script to execute the compilation process. After the compilation is completed, the build product is persistently stored or packaged according to the product save path and storage strategy defined in the structured configuration parameter file, and the build product information is fed back to the master node through a shared mount directory or file transfer protocol.

[0082] Specifically, the build node adopts a standardized container compilation environment and parameterized build process, which can effectively avoid environmental inconsistencies and configuration deviations during the build process, and improve the stability and repeatability of compilation tasks; thereby achieving the technical effects of improving build efficiency, reducing build failure rate, and improving the controllability of build products, providing reliable input guarantees for the subsequent testing phase.

[0083] Parallel test nodes are used to receive test tasks and build products distributed by the master node, execute test operations according to the structured configuration parameter file, generate a test product grid, perform quality analysis and feed the results back to the master node; Specifically, the parallel test nodes are deployed in a physical server environment or a containerized scheduling service environment. After receiving the build products and test tasks distributed by the master node, they automatically load the geometric data file, call the test tool to execute the mesh generation test task, and generate the test product mesh according to the test input path, execution script, parameter configuration and timeout strategy defined in the structured configuration parameter file; then load the mesh data based on the analysis rules, perform quality analysis of indicators including unit shape regularity, side length ratio, connectivity consistency, etc., and generate a structured test report according to the configuration requirements, and synchronously feed back the test products and analysis results to the master node.

[0084] Specifically, the parallel test nodes adopt a parameter-driven automatic testing and quality analysis mechanism, which can realize an efficient and unified grid testing and quality verification process, significantly shortening the test cycle; thereby achieving the technical effect of highly automated testing process, timely and accurate result feedback, and good system scalability, meeting the testing needs of parallel grid software in large-scale scenarios.

[0085] The three nodes communicate with each other to generate a schedulable test infrastructure environment and realize collaborative execution and data interaction of each test stage in a local area network or virtual network.

[0086] Specifically, if Figure 28 As shown, the three types of nodes are deployed in a virtualization platform or a physical server environment, and network connections are achieved through bridge bridging. The virtual nodes use virtual switches to bridge the virtual network cards to the physical network, while the physical nodes are connected to the same LAN switch via network cables, placing all nodes in a unified logical Layer 2 network and supporting direct IP-based communication. This architecture offers excellent flexibility and scalability, enabling seamless addition or replacement of nodes in different deployment environments, supporting dynamic expansion of the test process and multi-node collaboration. Because it adopts a unified network architecture based on Bridge and is flexible and compatible with hybrid deployment of virtual machines and physical nodes, it can achieve flexible expansion of the deployment structure while ensuring network communication stability. This achieves the technical benefits of convenient deployment, efficient node intercommunication, and sustainable expansion of the test system, providing excellent network support for the stable operation of large-scale parallel test systems.

[0087] Those skilled in the art will readily appreciate other embodiments of the present application after considering the specification and practicing the contents disclosed herein. This application is intended to cover any variations, uses, or adaptations of the present application that follow the general principles of the present application and include common knowledge or customary techniques in the art not disclosed herein. The description and examples are to be considered merely as exemplary, and the true scope and spirit of the present application are indicated by the claims.

[0088] It should be understood that the present application is not limited to the exact structures described above and shown in the drawings, and that various modifications and changes may be made without departing from the scope thereof. The scope of the present application is limited only by the appended claims.

Claims

1. A method for supporting automated testing of parallel grid generation software, characterized in that: include: Deploy master nodes, build nodes, and parallel test nodes, establish connections between nodes, and generate a schedulable test infrastructure environment; According to the test basic environment, obtain the structured configuration parameter files required for compilation tasks, test tasks and quality analysis; According to the structured configuration parameter file, when the master control node detects a preset event, it distributes the compilation task to the construction node to generate a construction product; According to the structured configuration parameter file, after the compilation task is completed, distributing the build product to the parallel test node; executing a test task on the build product on the parallel test node according to the structured configuration parameter file to generate a test product grid; According to the structured configuration parameter file, quality analysis is performed on the test product grid to generate a corresponding test report.

2. A method for supporting automated testing of parallel grid generation software according to claim 1, characterized in that: Deploy the master node, build nodes, and parallel test nodes, establish connections between the nodes, and generate a schedulable test infrastructure, including: On Linux systems, the container management platform is used to deploy the operating environment of the master node in the master node to support high-availability operation of the scheduling service. The master node is responsible for receiving task trigger events, unifying the scheduling of build and test processes, and coordinating the parallel execution of multiple nodes. On Linux systems, a compilation environment is deployed on build nodes through a container management platform to support efficient compilation task execution. The build nodes are responsible for receiving compilation tasks from the master node, executing related build processes, generating build artifacts, and ensuring efficient collaboration and task transmission with other nodes. On Linux systems, a test environment is deployed in parallel test nodes through a container management platform to support efficient test task execution. The parallel test nodes are responsible for receiving build products from build nodes and test tasks from the master node, executing the corresponding test processes, and feeding back test reports to the master node. Configure a virtual network in the LAN environment, establish a connection between the virtual network card in the container and the LAN, and ensure that the master node, build node, and parallel test node can interconnect efficiently and securely.

3. The method for supporting automated testing of parallel grid generation software according to claim 1, characterized in that: Based on the test infrastructure, obtain the structured configuration parameter files required for compilation tasks, test tasks, and quality analysis, including: Based on the source code location, dependency information, and compilation options described in the structured configuration parameter file, a script file for compilation is pre-written, and a command for calling the compilation script is written in the structured configuration parameter file to complete the automated compilation of the source code; In the structured configuration parameter file, define the product information that needs to be saved during the compilation and testing process, including the file path, directory path, storage period, and target storage location to be saved; In the structured configuration parameter file, define the execution content of the test phase, including the path of the test script, the test timeout period, and the handling strategy after the test failure; In the structured configuration parameter file, define the execution content of the quality analysis phase, including the name of the quality analysis tool, the path of the analysis script, the analysis parameter configuration, the quality threshold standard, and the name of the generated test report.

4. The method for supporting automated testing of parallel grid generation software according to claim 1, wherein: According to the structured configuration parameter file, when the master control node detects a preset event, it distributes the compilation task to the build node to generate a build product, specifically including: The master node continuously monitors preset trigger conditions. When an event that meets the trigger conditions is detected, it records the event information and prepares to start subsequent tasks. The trigger conditions include source code submission, branch merging, tag creation, or other operations related to version changes. The master node determines the compilation task content to be distributed based on the structured configuration parameter file, including the modules to be compiled and the compilation parameters; The master control node distributes the corresponding compilation task to the construction node according to the determined compilation task content, so that the construction node can subsequently perform the compilation operation; The build node receives the compilation task distributed by the master node, and performs the compilation operation according to the task content to generate the corresponding build product; The construction node persists the generated construction products according to the definition of product preservation in the structured configuration parameter file.

5. The method for supporting automated testing of parallel grid generation software according to claim 1, wherein: According to the structured configuration parameter file, after the compilation task is completed, the build product is distributed to the parallel test node, specifically including: The master control node determines the distribution rules according to the structured configuration parameter file, including the build products to be distributed and their corresponding parallel test nodes; The master control node will distribute the corresponding build products to the parallel test nodes according to the distribution rules; The parallel test nodes receive the build products distributed by the master node and prepare for subsequent testing operations.

6. The method for supporting automated testing of parallel grid generation software according to claim 1, characterized in that: Executing a test task on the build product on the parallel test node according to the structured configuration parameter file to generate a test product grid specifically includes: Determining test input content required for use in a test phase according to the structured configuration parameter file, wherein the test input content includes a pre-prepared geometric data file; Determine test execution rules according to the structured configuration parameter file, wherein the test execution rules include a test script path, test parameter configuration, test timeout, and test failure handling strategy; On the parallel test node, calling the build product, and executing the test task according to the determined test input content and the determined test execution rule; On the parallel test node, generating a test product grid according to the test task execution result; According to the structured configuration parameter file, a test product grid is persistently saved on the parallel test node.

7. The method for supporting automated testing of parallel grid generation software according to claim 1, characterized in that: Performing quality analysis on the test product grid according to the structured configuration parameter file and generating a corresponding test report, specifically including: Determine the index content that needs to be tested in the quality analysis phase according to the structured configuration parameter file, wherein the index content includes accuracy index and completeness index; Determining quality analysis rules according to the structured configuration parameter file, wherein the quality analysis rules include minimum angle, maximum angle, side length ratio, unit shape regularity, area consistency, and grid connectivity consistency; Loading the test product grid on the parallel test node as object data for quality analysis; On the parallel test node, performing quality analysis on the loaded test product grid according to the determined quality analysis rules to obtain detection results of various quality indicators; On the parallel test node, a corresponding test report is generated according to the test results of each quality indicator.

8. A device supporting automated testing of parallel grid generation software, characterized in that: include: The master node is used to listen to preset events, parse structured configuration parameter files, and distribute compilation tasks to build nodes; Receives build product information returned by the build node, distributes build products and test tasks to the parallel test node; receives the test product grid and quality analysis report returned by the parallel test node, and realizes unified scheduling and coordinated control of the entire automated test process; The build node receives the compilation tasks distributed by the master node, performs the compilation operations according to the structured configuration parameter file, generates the build products, and returns the build products to the master node; Parallel test nodes are used to receive test tasks and build products distributed by the master node, execute test operations according to the structured configuration parameter file, generate a test product grid, perform quality analysis and feed the results back to the master node; The three nodes communicate with each other to generate a schedulable test infrastructure environment and realize collaborative execution and data interaction of each test stage in a local area network or virtual network.

Images