A method and system for BIM software automated testing based on RPA

Abstract

The application discloses a kind of based on RPA BIM software automation test method and system.The method includes: through built-in embedded module, the interactive channel of two-way communication between RPA player and BIM software is established, the accurate driving of BIM software is realized;Create standardized test environment, system deployment includes input, output and document assets in basic test assets;Create the RPA automation test script of task-process-step hierarchical structure;Batch automation testing is carried out by forming OPR project file by organizing multiple scripts, and test report is generated.The corresponding system contains five modules of communication service, test asset management, test editing, test execution and test management.The application solves the problem of low BIM software test efficiency and strong artificial dependence, realizes the automation test and efficient regression verification of complex modeling process.

Description

Technical Field

[0001] This invention belongs to the technical field of computer-automated office operations, and particularly relates to a method and system for automated testing of BIM software based on RPA. Background Technology

[0002] In computer software development, to ensure the stability of software functionality and reduce rework costs during development iterations, a significant amount of human resources is typically invested in repetitive testing. However, manually performing heavy and repetitive testing operations is inefficient and prone to errors. More importantly, the testing process, which should be standardized, can lead to inconsistent test results due to the uncertainty of manual operation and the subjectivity of judgment, affecting the timeliness and accuracy of problem discovery.

[0003] For example, a company's large-scale BIM software, CyberStation, has over 10 million lines of code and is continuously iterated and updated. This software includes more than 300 basic tools and functional modules. It is crucial to ensure the normal operation of all functions after each update to prevent anomalies in other modules caused by feature enhancements or modifications. Failure to identify potential problems in a timely manner will significantly increase the cost of troubleshooting as subsequent code is integrated. Therefore, comprehensive testing must be completed within 8 hours of each version release. If manual testing is used, meeting these requirements would require more than 100 man-hours, or 12 testers, to meet the timeliness requirement. Furthermore, extensive and repetitive manual testing may be prone to assumptions, lack of rigor, and insufficient attention to detail, making it impossible to guarantee that all problems have been identified after testing.

[0004] While existing desktop software automation testing tools (such as TestComplete and UFT One) can achieve basic automation testing, such as automating the interface by recording keyboard and mouse operations, they have significant limitations when dealing with BIM software (such as CyberStation): they cannot support complex dynamic modeling operations and it is difficult to ensure the consistency of test data; in addition, these tools lack the ability to deeply judge the test results, requiring bidirectional embedding development, resulting in high overall implementation costs.

[0005] In addition to interface and performance testing, the most crucial aspect of automated testing for BIM software is verifying the functions and tools that users directly operate. Screenshots alone cannot accurately determine whether a function is working properly; further in-depth checks, such as BIM model information statistics and document comparison, are required. Summary of the Invention

[0006] To address the shortcomings of existing BIM software testing technologies, such as low efficiency, incomplete coverage, and inability to perform in-depth verification, this invention proposes a method and system for automated BIM software testing based on RPA. First, this invention establishes a bidirectional communication mechanism between the testing system and the internal functions of the BIM software by deploying embedded plug-in modules in the target BIM software. This enables the testing system to directly call and deeply verify the core functions of the BIM software. Then, RPA technology drives the test process execution, and combined with the professional verification capabilities provided by the embedded plug-in, such as model comparison, file verification, and rendering, a complete automated BIM software testing system is established. This achieves systematic, in-depth, and repeatable automated testing of various functions of the BIM software.

[0007] Therefore, the first objective of this invention is to provide a method for automated testing of BIM software based on RPA, which includes the following steps:

[0008] Establish an interactive channel for two-way communication between the RPA player and the BIM software;

[0009] Create an automated testing infrastructure environment and deploy basic testing assets to build the testing environment. The basic testing assets include input assets, output assets, and documentation assets.

[0010] Create an RPA automated test script for performing a specific test task. The RPA automated test script is organized in a hierarchical structure, including tasks, processes and steps, and defines the execution method of each step. The execution method includes at least sending the script to BIM software for execution via an interactive channel.

[0011] Summarize all the RPA automated test scripts, create an OPR project file, and execute automated tests based on the OPR project file to generate a test report.

[0012] Preferably, establishing an interactive channel for bidirectional communication between the RPA player and the BIM software includes:

[0013] An embedded module is deployed in the BIM software to build an interactive channel client, which is configured to execute a standardized set of instructions related to the internal operations and information extraction of the BIM software.

[0014] By listening to and accepting connection requests from the interaction channel client on the RPA player side, a stable bidirectional communication link is established between the RPA player and the BIM software.

[0015] Preferably, the creation of the automated testing infrastructure environment and the deployment of basic testing assets to build the testing environment includes:

[0016] Create a test workspace folder that uniquely corresponds to the test case. The test workspace folder has a specific subdirectory structure for storing input assets, output assets, and automated test scripts.

[0017] Deploy the basic BIM model files in the test workspace folder and verify the feasibility of the test process;

[0018] Configure the key environmental parameters required for automated testing, including the baseline screen point, the surrounding crop size, and the image similarity threshold.

[0019] Preferably, the creation of RPA automated test scripts for executing specific test tasks is described. These RPA automated test scripts are organized in a hierarchical structure, including tasks, processes, and steps, and define the execution method for each step. The execution method includes at least sending the script to BIM software for execution via an interactive channel, including:

[0020] Create an RPA automated test script within the test workspace folder;

[0021] The RPA automated test script is formed by defining and configuring one or more test processes, each process containing one or more test steps, and defining their execution methods. The execution methods include at least sending the test to BIM software for execution via an interactive channel.

[0022] The RPA automated test script is executed to generate a test verification benchmark file, which includes reference images and reference result files.

[0023] After modifying the RPA automated test script, re-execute it to update the test verification baseline file.

[0024] Preferably, the step of summarizing all the RPA automated test scripts, creating an OPR project file, and executing automated tests based on the OPR project file to generate a test report includes:

[0025] Compile RPA automated test scripts and set configuration parameters;

[0026] Create an OPR project file, import RPA automated test scripts or import RPA automated test scripts from other OPR project files, and create a list of RPA automated test scripts that reference the OPR project file;

[0027] The OPR project file will be executed to automatically generate a test report.

[0028] The second objective of this invention is to provide a system for automated testing of BIM software based on RPA, the system comprising:

[0029] The interactive channel establishment module establishes an interactive channel between the RPA player and the BIM software to enable two-way communication.

[0030] The test environment building module is used to create an automated test infrastructure environment and deploy basic test assets to build the test environment.

[0031] The RPA script creation module is used to create RPA automated test scripts for executing specific test tasks;

[0032] The test execution management module is used to aggregate all the RPA automated test scripts, create OPR project files, and execute automated tests based on the OPR project files.

[0033] Preferably, the interaction channel establishment module includes:

[0034] The communication client submodule is used to deploy embedded modules in BIM software and build interactive channel clients;

[0035] The communication service terminal module is used to listen for and accept connection requests from the interactive channel client through the interactive channel server on the RPA player side;

[0036] The communication protocol management submodule is used to dynamically manage the connection status and data processing between the interaction channel server and the interaction channel client.

[0037] Preferably, the RPA script creation module includes:

[0038] The script file management submodule is used to create an RPA automated test script within the test workspace folder.

[0039] The hierarchical editing submodule is used to define and configure one or more test processes, each containing one or more test steps, to collectively form the RPA automated test script;

[0040] The benchmark file generation submodule is used to execute the RPA automated test script to generate a test verification benchmark file;

[0041] The script maintenance submodule is used to modify the RPA automated test script and then re-execute it to update the test verification baseline file.

[0042] A third objective of this invention is to provide an electronic device comprising:

[0043] Memory, used to store computer programs;

[0044] A processor is used to execute programs stored in memory to implement any of the above-mentioned methods and steps for automated testing of BIM software based on RPA.

[0045] A fourth objective of this invention is to provide a computer-readable storage medium storing a computer program, which, when executed by a processor, implements any of the above-mentioned method steps for automated testing of BIM software based on RPA.

[0046] The beneficial effect of this invention lies in the fact that, through the deep integration of embedded modules and RPA technology, automated and in-depth testing of BIM software functions is achieved, including:

[0047] 1) It realizes automated in-depth testing of BIM software functions, and directly accesses and manipulates internal objects of BIM software through embedded modules, overcoming the limitation of traditional testing tools that can only simulate surface operations;

[0048] 2) A complete test case management system has been established, which achieves the repeatability of the testing process and the verifiability of the test results through the collaborative work of RPA scripts and embedded modules;

[0049] 3) A standardized test data organization method was adopted, and the consistency of test input and test environment was ensured through the test workspace folder mechanism;

[0050] 4) It provides a multi-level test result verification mechanism, which combines screenshot comparison and file comparison to ensure both testing efficiency and the accuracy of test results;

[0051] 5) It realizes the automated execution of the testing process and the automatic comparison of results, which significantly reduces manual intervention, improves testing efficiency, and reduces testing costs. Attached Figure Description

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

[0053] Figure 1 This is a schematic diagram of a method for automated testing of BIM software based on RPA according to the present invention.

[0054] Figure 2 A schematic diagram illustrating the configuration of the test process "starting CyberStation and opening a file" in an embodiment of the present invention;

[0055] Figure 3 A schematic diagram illustrating the "Start Elliptical Cone Tool" test process configuration for an embodiment of the present invention;

[0056] Figure 4 A schematic diagram of the "Draw Elliptical Cone Surface" setting dialog box that pops up in the "Window Setting Control" of the "Start Elliptical Cone Tool" test process in the embodiment of the present invention;

[0057] Figure 5 A schematic diagram illustrating the "window setting controls" in the "launch elliptic cone tool" test process configured according to an embodiment of the present invention;

[0058] Figure 6 A schematic diagram illustrating the "Creating a Test Process" step in configuring the test process according to an embodiment of the present invention;

[0059] Figure 7 A schematic diagram illustrating the configuration of the test process "Check and shut down CyberStation" for an embodiment of the present invention;

[0060] Figure 8 This is a schematic diagram illustrating the display of the RPA automated test script list after loading an OPR file, as per an embodiment of the present invention.

[0061] Figure 9 This is a schematic diagram comparing the differences between images in an embodiment of the present invention.

[0062] The accompanying drawings have illustrated specific embodiments of this disclosure, which will be described in more detail below. These drawings and descriptions are not intended to limit the scope of the concept in any way, but rather to illustrate the concepts of this disclosure to those skilled in the art through reference to particular embodiments. Detailed Implementation

[0063] The present invention will be further described in detail below with reference to the accompanying drawings and specific embodiments. Obviously, the described embodiments are only some, not all, of the embodiments of the present invention. All other embodiments obtained by those skilled in the art based on the described embodiments of the present invention without inventive effort are within the scope of protection of the present invention. Unless otherwise defined, the technical or scientific terms used herein should have the ordinary meaning understood by those skilled in the art to which this invention pertains.

[0064] Terminology Explanation

[0065] BIM stands for Building Information Modeling. It's not just about a 3D model, but a comprehensive information management process. At its core, it involves creating a digital information model encompassing all the physical and functional characteristics of a building. This model provides shared knowledge resources to all participants throughout the building's lifecycle, from conceptual design, construction, operation to maintenance and even demolition. Correspondingly, BIM software fully implements this process, enabling BIM modeling and drawing generation, BIM data consumption, and more.

[0066] Commands: In the context of BIM software, several of its functions / tools have user entry points, typically a series of easily understood characters typed by the user. These are called key-in commands. For example, typing "Place Line" in the BIM software command box will activate the line drawing tool.

[0067] RPA stands for Robotic Process Automation. It is an application software technology that simulates human actions on digital devices such as computers to automatically perform numerous, repetitive, rule-based tasks. The "robot" here refers to a software robot, not a physical robot.

[0068] Named pipe communication: a way for computer processes to exchange data or cooperate. Processes are independent entities and cannot communicate directly. They use a named medium to carry information and pass it to another process. This communication method is called named pipe communication, and the named medium is called a named pipe.

[0069] Example 1

[0070] To better understand the concept of automated testing of BIM software in this invention, this embodiment uses the large-scale BIM software CyberStation as the main testing object and takes the "elliptical cone-nonorthogonal" model established in CyberStation as an example to introduce the entire process of automated testing in detail.

[0071] This invention provides a method for automated testing of BIM software based on RPA, such as... Figure 1 As shown, it includes the following steps:

[0072] S1 establishes an interactive channel between the RPA player and the BIM software to enable two-way communication.

[0073] This invention provides an automated testing solution based on an RPA (Robotic Process Automation) player. Its core is to record and replay the user's modeling operation sequence in BIM software to achieve automated testing and verification of the BIM modeling process, model generation results, and the software's own functions.

[0074] To address the key technical challenge of accurately driving the internal operations of BIM software and reliably extracting its internal BIM information, this invention employs an interactive channel architecture based on an embedded module. This architecture builds a stable, bidirectional interactive channel by embedding a module within the BIM software, which acts as a communication proxy between the RPA player and the BIM software.

[0075] The establishment of this interactive channel is the sole communication foundation and necessary prerequisite for the correct implementation of all subsequent automated operations and information extraction. As a preferred implementation, the interactive channel is based on a named pipe communication mechanism. Step S1, establishing a bidirectional interactive channel between the RPA player and the BIM software, specifically includes the following sub-steps:

[0076] S11, Deploy an embedded module in the BIM software to build an interactive channel client, which is configured to execute a standardized set of instructions related to internal operations and information extraction of the BIM software.

[0077] An embedded module specifically developed for it is deployed in the BIM software (CyberStation in this embodiment). This module is loaded when the BIM software process starts and an interactive channel client is built inside it.

[0078] The core mission of the client is as follows: First, it actively establishes a communication connection with the interaction channel server on the RPA player side; then, it listens for requests from the server and completes the execution of a series of standardized instructions by calling the internal interfaces of the BIM software, including executing commands, saving BIM files, exporting BIM files, comparing BIM files, outputting specific content of BIM files, and rendering BIM files; finally, it returns the results of the instruction execution to the server, thereby achieving precise driving and automated testing of the BIM software.

[0079] It should be understood that for different types of BIM software, this invention needs to develop specific embedded modules adapted to them, but these different embedded modules all implement a completely unified standardized instruction set. The interactive channel client is configured to be implemented based on an inter-process communication mechanism, and its implementation methods include, but are not limited to: named pipe client, TCP / IP protocol client, or shared memory client. In this embodiment, a named pipe client is preferred, which together with the corresponding interactive channel server constitutes the stable bidirectional interactive channel.

[0080] S12, the RPA player listens for and accepts connection requests from the interaction channel client through the interaction channel server on the RPA player side, thereby establishing a stable bidirectional communication link between the RPA player and the BIM software.

[0081] When the RPA player initiates an automated testing task, it simultaneously creates and runs an interactive channel server. The server first continuously listens for and accepts connection requests from the interactive channel client in the BIM software (CyberStation in this embodiment) to establish a stable communication link. Then, the interactive channel server sends a standardized set of instructions, including modeling operations, interface simulation, information querying, and process control, to the connected interactive channel client to drive the BIM software to complete automated testing. Simultaneously, it receives and processes the instruction execution results and automatically reported events returned by the interactive channel client, thereby coordinating and verifying the testing process.

[0082] The interactive channel server is configured to be implemented based on an inter-process communication mechanism. Its implementation methods include, but are not limited to, named pipe server, TCP / IP protocol server or shared memory server. In this embodiment, named pipe server is preferred. It and the corresponding interactive channel client together constitute the stable bidirectional interactive channel.

[0083] S2, Create an automated testing infrastructure environment and deploy basic testing assets to build the testing environment. The basic testing assets include input assets, output assets, and documentation assets.

[0084] This step aims to build a standardized, isolated, and reproducible automated testing environment. By preparing dedicated test assets and pre-setting the set of configuration parameters, it ensures that each automated test is executed under consistent and controlled conditions, thereby guaranteeing the reliability, comparability, and repeatability of test results.

[0085] The test assets include:

[0086] 1) Input Assets: These refer to the initial resources pre-installed before test execution to drive the test; they are the starting point and basis for the test. These include:

[0087] Base BIM model file: A pre-defined, clean BIM model file that serves as the initial model environment for test execution. It ensures that each automated test starts from an identical, known, deterministic initial state, providing a fundamental guarantee for test repeatability.

[0088] Parameter configuration file: This predefines all the input parameters required to run test cases. These parameters are read by the RPA player at startup and used to precisely drive the BIM software to perform modeling operations, ensuring the consistency of test input.

[0089] Automated test scripts: Automated scripts (RPA files) parsed and executed by the RPA player. These automated test scripts define and encode the entire automated testing process and logic, and are the direct source of automated behavior.

[0090] 2) Output Assets: Results files automatically generated by the system during and after the test execution process, used for verification, analysis and archiving.

[0091] Final BIM model file: The final model file generated and saved by BIM software after the automated testing process is completed. This model file is the core output of the test and is used for subsequent model correctness verification, comparative analysis, and archiving.

[0092] Execution Log: A detailed text log automatically generated by the RPA player. It faithfully records the issuance of commands, status feedback, operation results (success / failure), and all system messages and error information in chronological order, serving as the core basis for problem localization, test tracing, and process analysis.

[0093] Benchmark files: Pre-saved reference images or data files deemed "correct" during key steps of the testing process, serving as authoritative comparison benchmarks for subsequent automated test results.

[0094] Test snapshots: Screenshots or temporary data files captured in real time at the same critical steps during each automated test execution are a direct data source for comparison with the benchmark file, used to verify whether the output of each test is consistent with expectations.

[0095] 3) Document assets: Explanatory documents.

[0096] To achieve the above objectives, this step specifically includes the following sub-steps:

[0097] S21. Create a test workspace folder that uniquely corresponds to the test case. The test workspace folder has a specific subdirectory structure for storing input assets, output assets, and automated test scripts.

[0098] Create a unique test workspace folder corresponding to the current test case, serving as a dedicated container for centralized management of all test assets. These test assets are systematically organized in specific subdirectories within the test workspace folder: input assets (such as the basic BIM model and parameter configuration files) are placed in the Input / directory, output assets (such as the final BIM model file, execution logs, baseline files, and test snapshots) are uniformly stored in the Output / directory, and automation scripts are stored in the RPAScript / directory.

[0099] This directory-based asset storage solution achieves physical isolation between test cases, effectively avoiding file tampering, resource contention, and data pollution. It serves as the structural foundation for ensuring the independence of the testing process and the repeatability of results.

[0100] Preferably, the test workspace folder can have the following directory structure, taking the "elliptic cone-nonorthogonal" model automatic test case as an example:

[0101] Elliptic cone - non-orthogonal

[0102] ├── Input /

[0103] │ ├── Elliptic Cone - Sample 1_bak.cdb

[0104] │ └── config.ini

[0105] ├── Output /

[0106] │ ├── Elliptic Cone - Sample 1.cdb

[0107] │ ├── ExecutionLog.txt

[0108] │ └── BaseFiles /

[0109] │ ├── Step1_BaseInitialView.png

[0110] │ ├── Step2_BaseAfterCreation.png

[0111] │ └── Step3_BaseFinalResult.png

[0112] │ └── …

[0113] │ └── Snapshots /

[0114] │ ├── Step1_InitialView.png

[0115] │ ├── Step2_AfterCreation.png

[0116] │ └── Step3_FinalResult.png

[0117] │ └── …

[0118] ├── RPAScript /

[0119] │ └── Elliptic Cone - Non-Orthogonal.rpa

[0120] └── README_TestCase.md

[0121] The technical meanings and functions of each directory and file are as follows:

[0122] Elliptic Cones - Non-Orthogonal / Table of Contents:

[0123] The root directory of the test cases defined in this embodiment.

[0124] Input / Directory:

[0125] Elliptic Cone - Sample 1_bak.cdb: The base BIM model file. It is the initial input for test execution, providing a pre-set clean BIM model environment to ensure that each test starts in an absolutely consistent state.

[0126] config.ini: Parameter configuration file. It stores key environmental parameters for test cases (such as baseline screen point, cropping size, and similarity threshold).

[0127] Output / Directory:

[0128] Elliptical Cone - Sample 1.cdb: During the automated test execution, the BIM software copied this file from Elliptical Cone - Sample 1_bak.cdb as a baseline file. This file is the result asset of the test, recording the final BIM model for subsequent BIM model correctness verification and archiving.

[0129] ExecutionLog.txt: A detailed log file automatically generated by the RPA player during the test. It records the command issuance, status feedback, operation results (success / failure) and possible error messages in chronological order. It is the core basis for problem localization and test analysis.

[0130] The BaseFiles / subdirectory contains benchmark files stored in the order of the test steps. These benchmark files include reference images and reference result files, serving as a comparison benchmark for performing test results and providing evidence for verifying the test results.

[0131] The Snapshots / subdirectory contains temporary image files and test snapshots stored in the order of the test steps. It is the direct data source for comparing test results and provides evidence for verifying the test results.

[0132] RPAScript / Directory:

[0133] Elliptic Cone - Non-Orthogonal.rpa: The RPA automated test script that drives this automated test execution. This RPA automated test script defines a complete automated test process, which is created manually using the RPA editor by setting the operation steps, or by recording manual operations to automate the creation of the operation steps.

[0134] README_TestCase.md: The documentation for the test case. It records the test purpose, preconditions, and operation steps in text format.

[0135] S22, Deploy the basic BIM model files in the test workspace folder and verify the feasibility of the test process.

[0136] In this embodiment, the basic BIM model file (such as a .cdb format file) required for testing is pre-installed in the "Input / " directory of the independent test workspace folder. This file provides a preset, clean initial environment for the BIM model.

[0137] Then, a preliminary process of manually performing a target modeling operation is carried out in the BIM software. This process aims to:

[0138] 1) Verify the basic files: Confirm that the basic BIM model files can be correctly loaded and recognized by the BIM software.

[0139] 2) Verify parameter validity: Ensure that the preset modeling parameters can drive the BIM software to generate a BIM model with the expected shape and attributes, and check whether its display effect (such as size and position) in the drawing area meets expectations.

[0140] 3) Verify the feasibility of the process: Confirm that the entire manual operation process, from starting the software to executing the modeling command, is logically sound and without any software anomalies or logical errors.

[0141] After manual verification is complete, the model created must be deleted and the BIM software closed. This operation ensures that the base BIM model file reverts to its original state before this test case was executed.

[0142] This manual verification verifies the rationality of the test process and parameter configuration, laying a reliable foundation for subsequent automated testing. More importantly, it ensures that every automated test starts from the exact same, known, and constant initial conditions, fundamentally eliminating result fluctuations caused by differences in the initial state of the test environment. This is a key prerequisite for ensuring the repeatability of test results.

[0143] S23, Configure the key environmental parameters required for automated testing, including the baseline screen point, the surrounding cropping size, and the image similarity threshold.

[0144] Reference screen point: Defined as the absolute coordinate point (X0, Y0) of the top-left corner of the client area within the main window of the BIM software in the screen coordinate system. All subsequent interactive operations based on screen coordinates (such as clicking and dragging) calculate relative coordinates with the reference screen point as the origin. By dynamically acquiring or pre-calibrating the reference screen point, automated test scripts can automatically adapt to different screen resolutions, multi-monitor environments, and the position of the BIM software window.

[0145] Cropping width on all four sides: Defines the pixel width of the cropped area from the main window screenshot of the BIM software in four directions: top, bottom, left, and right. Cropping width on all four sides is used to exclude non-core and easily changing UI elements such as the title bar, menu bar, status bar, and toolbar during image comparison, ensuring that image similarity comparison focuses on the core model drawing area.

[0146] Image similarity threshold: defined as the lower limit of similarity for determining whether two screenshots are identical. For complex 3D graphics generated by BIM software, the image similarity threshold needs to be set within a very high precision range (preferably not lower than 0.999 in this embodiment). This parameter directly determines the rigor of visual verification of the model generation results in automated testing; the higher the threshold, the stricter the judgment and the lower the tolerance for error.

[0147] The environmental parameters are typically configured once during test project initialization. Except for the "baseline screen point," which may require recalibration due to different display devices, all test cases under the same project should follow a uniform parameter configuration to maintain consistency in testing standards.

[0148] This embodiment uses the creation of an "elliptic cone-nonorthogonal" model in CyberStation software as an example to illustrate the entire process of test environment configuration and parameter initialization:

[0149] 1) Execute step S21 to create a separate test workspace folder:

[0150] Create a separate test workspace folder named "Elliptic Cone - Non-Orthogonal" as the dedicated workspace for this test case to ensure isolation and data independence during the testing process.

[0151] 2) Execute step S22 to deploy the basic BIM model files required for automated testing:

[0152] Launch the CyberStation software. In the aforementioned "Elliptical Cone - Non-Orthogonal" test workspace folder, create a new basic BIM model file named "Elliptical Cone - Sample 1_bak.cdb" and open it. Then, based on the preset elliptical cone model parameters, manually execute the complete modeling process within the opened .cdb file. The core objective is to verify that the parameters can drive the software to generate the expected geometry, and that the generated model displays correctly and at the appropriate size in the drawing area. After verification, delete the created elliptical cone model and close the CyberStation software, returning the environment to its initial state, thereby empirically verifying the feasibility of the test process and the rationality of the parameters.

[0153] This .cdb file serves as the initial base BIM model file for testing, providing a defined initial state and input conditions for automated testing.

[0154] 3) Execute step S23 to set key environmental parameters:

[0155] Configure the following key environment parameters in the RPA player and save them to the parameter configuration file. This configuration typically only needs to be done once during project initialization. These include:

[0156] Set a reference screen point: Defined as the screen coordinate point at the top left corner of the client area of ​​the CyberStation software's main window. All subsequent coordinate-based operations will use this point as a reference to calculate relative coordinates, thereby enabling automated scripts to adapt to different resolutions and multi-screen display environments.

[0157] Set the cropping dimensions: Define the pixel dimensions for cropping the non-core areas around the edges of the main software interface screenshot. This effectively eliminates interference from changeable UI elements (such as toolbars and status bars) in image comparison.

[0158] Set an image similarity threshold: Set a similarity threshold to determine whether two screenshots are identical. For graphical output generated by BIM software, this threshold needs to be set at a high precision level (usually not lower than 0.999) to ensure the accuracy of model rendering result verification.

[0159] S3, Create an RPA automated test script for performing a specific test task. The RPA automated test script is organized in a hierarchical structure, including tasks, processes and steps, and defines the execution method of each step. The execution method includes at least sending the script to BIM software for execution via an interactive channel.

[0160] An RPA automated test script is created to perform a specific task. Executing this script completes automated testing according to the task definition. The task comprises several procedures (TaskDef), each procedure contains several steps (ActionDef), and each step (ActionDef) contains several parameters to simulate a specific input / output action. A procedure (TaskDef) is a meaningful combination of steps describing the simulated input device action. Procedures (TaskDef) can be created and modified by manually adding steps (ActionDef), or they can be automatically generated by recording manual operations.

[0161] The RPA automated test scripts can be organized using a hierarchical JSON structure:

[0162] 1) Task: Describes the top-level container and organizational unit of a complete automated test case. It uses a structured data format to encapsulate global information about the test case.

[0163] A task is recorded in an RPA automated test script, meaning that the RPA automated test script corresponds to a task that can be independently loaded, parsed, and executed by the RPA player. Task parameters include GUID, description, recording information, and a list of processes (Tasks). Preferably, the task parameter list can be as shown in the table below:

[0164] Table 1 Task Parameter List

[0165]

[0166] 2) TaskDef: The task definition's list of tasks contains several tasks, forming modular functional components of the RPA automated test script. A taskdef defines a reusable, automated operation fragment with clear business semantics, used to complete a relatively independent functional sub-goal. By logically combining a series of steps (actiondefs), it achieves the abstraction and structuring of the test script, thereby improving its readability, maintainability, and reusability.

[0167] Each TaskDef parameter includes a name, description, and a list of actions. Preferably, the TaskDef parameter list can be as shown in the table below:

[0168] Table 2. List of parameters for the procedure (TaskDef)

[0169]

[0170] 3) ActionDef: The smallest executable unit constituting a TaskDef, it is the final instruction carrier that enables the RPA player to directly drive BIM software or perform verification. Each Actions list contains a set of specific, automatable ActionDefs. Each ActionDef is an executable unit, including the action type, lead time, and detailed parameters for each action. The execution methods of the actions are as follows:

[0171] 1) Send commands to BIM software via interactive channels, including sending commands and comparing files.

[0172] 2) The RPA player can directly call the operating system interface to execute operations without going through the interactive channel: mouse operations, keyboard operations, window operations, getting / setting values ​​for form controls, file operations, opening applications, screen capture / screenshot, and comparing images.

[0173] It should be noted that during the editing phase, the file comparison step is executed by the RPA player directly calling the operating system interface to copy files in the same folder; during the testing phase, the files are sent to the BIM software through an interactive channel to compare the differences between the two files.

[0174] The parameters of a step can be expressed using JSON fragments, and the parameters differ depending on the type of step. It is important to note that each action type has a preload time, which sets the waiting period before executing the step. Aside from the preload time, the other parameters of the step (ActionDef) are preferably described in the table below:

[0175] Table 3. Step (ActionDef) Parameter Table

[0176]

[0177] S31. Create an RPA automated test script in the test workspace folder.

[0178] In this example, an automated test script named "Elliptic Cone - Non-Orthogonal.RPA" was created in the "Elliptic Cone - Non-Orthogonal" test workspace folder.

[0179] S32, by defining and configuring one or more test processes, each process containing one or more test steps, and defining their execution methods, the RPA automated test script is formed together, wherein the execution methods include at least sending to BIM software for execution via an interactive channel.

[0180] The entire process of building an automated testing model is required, including establishing the testing process and editing the test steps and parameters for each step. The editing interface is as follows: Figure 2 As shown.

[0181] In this embodiment, based on the entire process of establishing the "elliptic cone-nonorthogonal" model, the test process is designed as follows: start CyberStation and open the file, start the elliptic cone tool, create the process, and check and close CyberStation.

[0182] Then edit the steps of each process and the parameters of each step:

[0183] 1) Launch CyberStation and open the RPA automated test script: This process consists of two steps: "Open the application" and "Mouse movement," as follows... Figure 2 As shown.

[0184] The "Open Application" option launches CyberStation. Its parameters, external program and parameter, are set to the path to CyberStation.exe and the file "Elliptic Cone-Sample1.cdb," respectively. This means that launching CyberStation will simultaneously open "Elliptic Cone-Sample1.cdb" located in the "Input / " directory of the test workspace folder containing the RPA automated test script. It is important to note that if "Elliptic Cone-Sample1.cdb" does not exist in the test workspace folder, the RPA automated test script will automatically copy a "Elliptic Cone-Sample1.cdb" file from "Elliptic Cone-Sample1_bak.cdb" during execution, thus ensuring the consistency of the original data.

[0185] "Mouse movement" is the wait step, set to 5000 milliseconds, so that CyberStation can fully start and open the "Elliptic Cone - Sample 1.cdb" file.

[0186] 2) Launching the Elliptical Cone Tool: This process consists of 5 steps: "Send Command," "Move Window," and three consecutive "Window Settings Controls" steps, such as... Figure 3 As shown.

[0187] "Send command" sends a keyin command to CyberStation through the interactive channel. The keyin command parameter is "Cyber ​​Create DrawEllipticalConicSurface" to start the tool for drawing elliptical cone surfaces and pop up the dialog box "Draw Elliptical Conical Surface".

[0188] "Move Window" means moving the dialog box "Draw Elliptical Cone Surface" to the left to avoid obscuring the center of the drawing area.

[0189] In the "Window Settings Controls" dialog box, the "Orthogonal" control in the "Draw Elliptical Cone Surface" setting is unchecked, indicating that a non-orthogonal elliptical cone will be created. Figure 4 As shown;

[0190] When the "Draw Elliptical Cone Surface" control in the "Window Settings Control" dialog box is checked, the height of the elliptical cone will be limited, and the user will need to enter a height value afterward.

[0191] In the "Window Settings Control" dialog box, enter the value 150 in the text box after "Height" for the "Draw Elliptical Cone Surface" control. Figure 5 As shown, the height of the elliptical cone is limited to 150.

[0192] 3) Creation Process: This is a recording process. After the operator executes Process 1 and Process 2, they start the operation recorder. Using the mouse in the drawing area, they create an elliptical cone. The recorder automatically records all mouse and keyboard actions and generates a name for each recorded action, representing the steps of that action. Figure 6 As shown.

[0193] 4) Check and close CyberStation: This process consists of four steps: "Mouse movement", "Compare screenshots", "Compare files", and "Mouse click". Figure 7 As shown.

[0194] "Move mouse" means moving the mouse out of the drawing area to facilitate taking a screenshot.

[0195] The "Compare Screenshots" checkpoint requires a screenshot name, such as "Results Screenshots". When this step is executed during the test editing phase, a screenshot reference image named "Results Screenshots.png" will be automatically generated in the "Output / BaseFiles / " directory of the current test workspace folder. When executed during the automated test phase, a result image with the date will be automatically generated in the current test workspace folder, such as "Results Screenshots 20250601.png". By comparing these two images, you can initially determine whether the results are consistent and thus infer whether the test is normal.

[0196] "Compare Files" is also a check node, which requires a file name, such as "check-elliptic cone non-orthogonal.cdb". During the editing test process, it will automatically copy the currently opened cdb file to "check-elliptic cone non-orthogonal.cdb" in the same test workspace folder. During the automated test, it will compare the differences between the currently opened cdb file and the file with this name by calling the embedded module of the BIM software CyberStation, so as to more accurately determine whether the test results are normal.

[0197] The "mouse click" step means clicking the "X" in the upper right corner of CyberStation to actively close CyberStation.

[0198] S33, Execute the RPA automated test script to generate a test verification benchmark file, the benchmark file including reference images and reference result files.

[0199] The RPA player is invoked to execute the process defined in step S32 to generate a benchmark file. This benchmark file contains reference images and reference result files, both of which are saved in the corresponding directories of the test workspace folder. In subsequent automated testing, executing the RPA automated test scripts generates corresponding temporary image files and test snapshots, which are also saved in the corresponding directories of the test workspace folder. Finally, the system uses a dual verification mechanism of image comparison and file content comparison to comprehensively determine whether the testing tool is functioning correctly.

[0200] S34. After modifying the RPA automated test script, re-execute it to update the test verification benchmark file.

[0201] If the process, the steps of the process, or the parameters of the steps are modified or adjusted, then after the modification or adjustment is completed, step S33 will be re-executed and the node reference data will be saved.

[0202] In particular, when the screen environment changes, it is necessary to re-execute step S23 to set the configuration parameters, and to batch revise the screen coordinate parameters for all processes as needed.

[0203] S4. Summarize all the RPA automated test scripts, create an OPR project file, and execute automated tests based on the OPR project file to generate a test report.

[0204] An OPR project file is created to execute a specific group of test tasks. This OPR project file serves as the core scheduling and management unit, aiming to organize, execute, and manage RPA automated test scripts in batches. It also supports complex, nested test project structures through referencing, such as... Figure 8 As shown.

[0205] The RPA player is used to automatically play RPA automated test scripts in a collection of OPR project files, compare and judge according to the instructions of the RPA automated test scripts, and save intermediate results (screenshots, files, etc.).

[0206] OPR project files can directly reference RPA automated test scripts, or they can indirectly reference RPA automated test scripts by referencing other OPR files.

[0207] The OPR project files can be organized using a hierarchical JSON structure.

[0208] 1) Top-level fields in OPR project files.

[0209] This defines the root hierarchy of the OPR project file, which serves as the entry point and container for all test tasks. Preferably, the top-level field parameters of the OPR project file can be as shown in the table below:

[0210] Table 4. List of Top-Level Field Parameters in OPR Project Files

[0211]

[0212] 2) OperateWorkDef object parameters.

[0213] It defines how a single RPA automated test script is represented in an OPR project. It not only defines the configuration before execution but also updates the logs and status reports recording the execution results after the script completes, such as execution start time, execution stop time, process information, operation status, working status, comparison results, and detailed comparison parameters.

[0214] The OperateWorkDef object parameters reference the RPA automated test script definition. Preferably, the OperateWorkDef object parameters can be as shown in the table below:

[0215] Table 5. List of OperateWorkDef Object Parameters

[0216]

[0217] The "Detailed Comparison Parameters" section is specifically designed for recording and managing visual comparisons or step-by-step result verifications during the testing process. It provides data structure support for implementing the "Saving Intermediate Results" and "Comparison Judgment" functions. Preferably, the "Detailed Comparison Parameters" section can be as shown in the table below:

[0218] Table 6. Detailed Parameter List

[0219]

[0220] 3) RefOPRDef object parameters.

[0221] This defines how one OPR project can reference another OPR project. This is the core mechanism for achieving modularity and reusability of test tasks. As a preferred option, the parameters of the RefOPRDef object can be as shown in the table below:

[0222] Table 7 Parameter Table for RefOPRDef Objects

[0223]

[0224] S41 summarizes the RPA automated test scripts and sets the configuration parameters.

[0225] Organize and summarize the test workspace folders to which all RPA automated test scripts created in step S21 belong, and then set the configuration parameters according to step S23 to adapt to the current multi-screen running environment.

[0226] S42, Create an OPR project file, import RPA automated test scripts or import RPA automated test scripts from other OPR project files, and create a list of RPA automated test scripts that reference the OPR project file.

[0227] S43, executes OPR project files to automatically generate test reports.

[0228] Executes the current OPR project file. After executing the RPA automated test script through the OPR project file, various fields in the section referencing the RPA automated test script definition will be updated in the current OPR project file, such as execution start time, execution stop time, process information, operation status, working status, comparison results, and detailed comparison parameters. Specifically, for cases where RPA automated test scripts are indirectly referenced, this modification applies to the referenced OPR project file.

[0229] After the OPR file automatically executes all the test tasks defined in the RPA automated test scripts, it generates a test report. That is, after the batch automated execution of the RPA automated test scripts, the execution information is written to the OPR project file. By parsing the OPR project file and the referenced OPR project files, the execution status of each RPA automated test script can be known. Finally, the program automatically generates reports, in which the reports show the pass / fail status of each test case, and the reports show the number of test cases executed and the number of test cases that failed.

[0230] The automated reports and statements are then manually processed to generate the final reports and statements, including:

[0231] 1) For each RPA automated test script that fails to execute or does not complete the execution process, the program displays its execution process parameters, and the error modules, running files, running parameters, screenshots, etc. are manually summarized, identified, and marked.

[0232] 2) For situations where there are differences between the images being compared, such as... Figure 9 As shown, reference and temporary images are automatically displayed, allowing manual judgment to determine whether the test has actually been successful, ignoring minor differences in the images. Furthermore, if a manual judgment determines that the temporary image is correct, it can be set as the reference image to ensure that subsequent automated tests identify no discrepancies.

[0233] Once the development team receives the manually processed reports and summaries, they can modify the model and program based on the test results.

[0234] In one alternative implementation, after step S4, the method further includes step S5, performing OPR project file changes and re-executing automated tests.

[0235] When adding, deleting, modifying, or adjusting the execution order of referenced RPA automated test scripts, the process of modifying the RPA automated test scripts requires executing step S34. Specifically, when dealing with changes in the screen environment, configuration parameters need to be reset, and screen coordinate parameters for all RPA automated test scripts need to be revised in batches as needed. Then, step S43 is executed again to re-execute the automatic generation of test reports from the OPR project file.

[0236] Example 2

[0237] This embodiment provides a system for automated testing of BIM software based on Robotic Process Automation (RPA). It is used to collaborate with specific BIM software such as CyberStation to automate the testing, verification, and regression testing of various functions and modeling processes of the BIM software. The core of the system consists of two main execution components: an RPA editor and an RPA player. It interacts with the BIM software through a communication service layer, and is ultimately managed and scheduled by a unified test management platform. Includes:

[0238] 1. Interactive Channel Establishment Module: Establishes an interactive channel between the RPA player and the BIM software to enable two-way communication.

[0239] By defining a standardized set of instructions independent of the BIM software interface, the interaction channel facilitates the exchange of instructions and data with the internal functions of the BIM software. The interaction channel establishment module is loaded upon system startup and includes:

[0240] 1) Communication Client Submodule, used to deploy embedded modules in BIM software and build interactive channel clients.

[0241] Based on the interactive channel's operating mechanism, this embodiment preferably uses named pipes. An interactive channel client is created by embedding a plugin on the BIM software side. This client is responsible for calling the BIM software's internal interface to execute standardized instruction sets, including functions such as executing commands, saving BIM files, exporting BIM files, comparing BIM files, outputting specific content from BIM files, and rendering BIM files.

[0242] 2) Communication service terminal module, used to listen for and accept connection requests from the interactive channel client through the interactive channel server on the RPA player side.

[0243] An interactive channel server is created on the RPA player side to continuously listen for and accept connection requests from the interactive channel client in the BIM software, establish a stable communication link, and send a standardized set of instructions, including executing commands, saving BIM files, exporting BIM files, comparing BIM files, outputting specific content of BIM files, and rendering BIM files.

[0244] 3) Communication protocol management submodule, used to dynamically manage the connection status and data processing between the interactive channel server and the interactive channel client.

[0245] It is responsible for creating, maintaining, and terminating sessions to ensure the stability of the communication link; when sending data, it serializes operation requests into standardized JSON data packets, and when receiving data, it deserializes the returned results into a standardized format that can be recognized internally by the system.

[0246] 2. Test Environment Building Module: This module is used to create an automated testing infrastructure environment and deploy basic test assets to build the test environment.

[0247] This module is responsible for building a standardized, isolated, and reproducible automated testing environment. By preparing dedicated test assets and pre-setting configuration parameter sets, it ensures that every automated test is executed under consistent and controlled conditions. This includes:

[0248] 1) The workspace management submodule is used to create a test workspace folder that uniquely corresponds to the test case.

[0249] Ideally, a test workspace folder with a standardized subdirectory structure should be created, containing the Input / directory for storing input assets, including basic BIM model files and parameter configuration files; the Output / directory for storing output assets, including final BIM model files, execution logs, benchmark files, and test snapshots; and the RPAScript / directory for storing automated test scripts.

[0250] 2) Basic Asset Deployment Submodule, used to deploy basic BIM model files to the test workspace folder and verify the feasibility of the test process.

[0251] Responsible for pre-setting basic BIM model files, such as .cdb format files, to the Input / directory, and verifying the loadability of basic files, the validity of parameters, and the feasibility of the process by manually executing the target modeling operation process, ensuring that the test environment returns to its initial state.

[0252] 3) Environment parameter configuration submodule, used to configure the key environment parameters required for automated testing.

[0253] Configure the baseline screen point: the screen coordinates of the upper left corner of the client area in the main window of the BIM software;

[0254] Cropping dimensions around the perimeter: The pixel dimensions of the non-core UI area cropped from the screenshot;

[0255] Image similarity threshold: usually set to no less than 0.999, and these parameters are persistently saved to the configuration file.

[0256] 3. RPA script creation module, used to create RPA automated test scripts for executing specific test tasks.

[0257] The core of this module is the RPA editor, which provides hierarchical script editing capabilities for creating, configuring, and orchestrating automated test steps and generating RPA automated test scripts that record these steps. It includes the following sub-modules:

[0258] 1) The script file management submodule is used to create an RPA automated test script within the test workspace folder.

[0259] Responsible for creating and managing .rpa script files, managing script file versions and change history, as well as metadata such as script GUID, description, and recording information.

[0260] 2) The hierarchical editing submodule is used to define and configure one or more test processes, each of which contains one or more test steps, to collectively form the RPA automated test script.

[0261] It provides task-level editing functions for managing global information and process lists; process-level editing functions for managing the name, description, and step list of TaskDef; and step-level editing functions for selecting action types, configuring parameters, and specifying execution methods.

[0262] The system supports automatically recording user operation steps via an operation recorder, or manually adding and configuring standard operation steps.

[0263] 3) Benchmark file generation submodule, used to execute the RPA automated test script to generate test verification benchmark files.

[0264] The RPA player is invoked to execute the currently orchestrated test script. In key verification steps, such as "comparing screenshots" and "comparing files", benchmark files, such as reference images and reference result files, are automatically generated and saved to the Output / BaseFiles / directory as authoritative basis for subsequent automated test comparisons.

[0265] 4) Script maintenance submodule, used to modify the RPA automated test script and then re-execute it to update the test verification benchmark file.

[0266] It supports modification and adjustment of processes, steps, and parameters, batch revision of screen coordinate parameters when the screen environment changes, and re-execution of scripts to update the baseline file.

[0267] 4. The test execution management module is used to summarize all the RPA automated test scripts, create OPR project files, and execute automated tests based on the OPR project files.

[0268] The core of this module is the RPA player, an execution engine specifically designed for automated testing. It is responsible for batch executing test cases and generating test reports. It includes:

[0269] 1) Project summary submodule, used to summarize RPA automated test scripts and set configuration parameters.

[0270] Organize and summarize all test workspace folders, configure multi-screen runtime environment parameters, and check the integrity and availability of test assets.

[0271] 2) The OPR project management submodule is used to create OPR project files, import RPA automated test scripts, or import RPA automated test scripts from other OPR project files.

[0272] Create OPR project files, manage top-level fields such as guid, description, Operates, and Refs, and create a list of OperateWorkDef objects that directly reference RPA automated test scripts and a list of RefOPRDef objects that indirectly reference other OPR files.

[0273] 3) Batch execution and reporting submodule, used to automatically generate test reports from OPR project files.

[0274] The system schedules the RPA player to execute all test cases in batches, monitors the execution status in real time, and collects execution results and comparison data. It generates structured test reports by parsing OPR project files, displaying the test pass rate, failure cases, and detailed error information. It also provides a manual processing interface for comparing difference images and confirming results.

[0275] In one alternative implementation, a system for automated testing of BIM software based on RPA further includes:

[0276] 5. Change management module, used to execute OPR project file changes and re-execute automated tests.

[0277] Establish a change and maintenance mechanism for test cases and test projects. When adding, deleting, modifying, or adjusting the execution order of referenced RPA automated test scripts, ensure that the test case scripts and test project files are updated synchronously. This includes:

[0278] 1) Reference Management Submodule: Used to manage the addition, deletion, modification, and order adjustment of RPA automated test scripts.

[0279] 2) Environment reconfiguration submodule: Resets configuration parameters when the screen environment changes, and batch revises the screen coordinates of all related scripts.

[0280] 3) Re-execute submodule: Trigger the re-execution of the OPR project file to verify the correctness of the changes and update the test report.

[0281] Example 3

[0282] This embodiment proposes an electronic device, including:

[0283] Memory, used to store computer programs;

[0284] The processor is used to execute the program stored in the memory to implement the steps of the above embodiment of the method for automated testing of BIM software based on RPA.

[0285] For details on the specific implementation of each step and related explanations, please refer to the aforementioned embodiment of a method for automated testing of BIM software based on RPA, which will not be repeated here.

[0286] The memory of the electronic device mentioned in this embodiment may include random access memory (RAM) or non-volatile memory (NVM), such as at least one disk storage device.

[0287] The processors mentioned above can be general-purpose processors, including central processing units (CPUs), network processors (NPs), etc.; they can also be digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components.

[0288] Example 4

[0289] This invention also proposes a computer-readable storage medium storing a computer program. When executed by a processor, this computer program implements the steps of the above-described method embodiment for automated testing of BIM software based on RPA. For details on the specific implementation and explanation of each step of this method, please refer to the aforementioned method embodiment for automated design based on BIM software, which will not be repeated here.

[0290] The above description is merely an embodiment of the present invention and is not intended to limit the invention. Various modifications and variations can be made to the present invention by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principle of the present invention should be included within the scope of the claims of the present invention.

Claims

1. A method for BIM software automated testing based on RPA, characterized in that, include: Establishing a bidirectional communication channel between the RPA player and BIM software includes: deploying an embedded module in the BIM software to build an interactive channel client, which is configured to execute a standardized set of instructions related to internal operations and information extraction within the BIM software; the interactive channel client is responsible for calling the internal interfaces of the BIM software to execute the standardized set of instructions, including executing commands, saving BIM files, exporting BIM files, comparing BIM files, outputting specific content of BIM files, and rendering BIM files; establishing a stable bidirectional communication link between the RPA player and the BIM software by listening for and accepting connection requests from the interactive channel client through the interactive channel server on the RPA player side; and creating an automated testing infrastructure environment and deploying basic testing assets to build the testing environment, including input assets, output assets, and document assets. Create an RPA automated test script for executing a specific test task. The RPA automated test script is organized in a hierarchical structure, including tasks, processes and steps, and defines the execution method of each step. The execution method includes sending the script to the BIM software for execution through an interactive channel, and executing the script by directly calling the operating system interface of the RPA player without going through an interactive channel. Summarize all the RPA automated test scripts, create an OPR project file, and execute automated tests based on the OPR project file to generate a test report.

2. The method of claim 1, wherein, The process of creating an automated testing infrastructure and deploying basic testing assets to build the testing environment includes: Create a test workspace folder that uniquely corresponds to the test case. The test workspace folder has a specific subdirectory structure for storing input assets, output assets, and automated test scripts. Deploy the basic BIM model files in the test workspace folder and verify the feasibility of the test process; Configure the key environmental parameters required for automated testing, including the baseline screen point, the surrounding crop size, and the image similarity threshold.

3. The method of claim 2, wherein, The creation of RPA automated test scripts for executing specific test tasks is described. These scripts are organized in a hierarchical structure, including tasks, processes, and steps, and define the execution method for each step. The execution methods include sending the script to BIM software via an interactive channel, and executing it directly by the RPA player calling the operating system interface without an interactive channel. Create an RPA automated test script within the test workspace folder; The RPA automated test script is formed by defining and configuring one or more test processes, each process containing one or more test steps, and defining their execution methods. The execution methods include sending the test script to the BIM software for execution via an interactive channel, and executing the test script by directly calling the operating system interface of the RPA player without using an interactive channel. The RPA automated test script is executed to generate a test verification benchmark file, which includes reference images and reference result files. After modifying the RPA automated test script, re-execute it to update the test verification baseline file.

4. The method of claim 1, wherein, The process involves summarizing all the RPA automated test scripts, creating an OPR project file, and executing automated tests based on this OPR project file to generate a test report, including: Compile RPA automated test scripts and set configuration parameters; Create an OPR project file, import RPA automated test scripts or import RPA automated test scripts from other OPR project files, and create a list of RPA automated test scripts that reference the OPR project file; The OPR project file will be executed to automatically generate a test report.

5. A system for BIM software automated testing based on RPA, characterized by, include: The interactive channel establishment module establishes a two-way communication channel between the RPA player and the BIM software. This module includes: a communication client submodule, used to deploy an embedded module in the BIM software and build an interactive channel client. This client is responsible for calling the BIM software's internal interfaces to execute standardized instruction sets, including functions such as executing commands, saving BIM files, exporting BIM files, comparing BIM files, outputting specific content from BIM files, and rendering BIM files; a communication server submodule, used to listen for and accept connection requests from the interactive channel client through the interactive channel server on the RPA player side, establishing a stable two-way communication link; and a communication protocol management submodule, used to dynamically manage the connection status and data processing between the interactive channel server and the interactive channel client. The test environment building module is used to create an automated test infrastructure environment and deploy basic test assets to build the test environment. The RPA script creation module is used to create RPA automated test scripts for executing specific test tasks. The RPA automated test scripts are organized in a hierarchical structure, including tasks, processes, and steps, and define the execution method of each step. The execution methods include sending the scripts to the BIM software for execution through an interactive channel, and executing the scripts by directly calling the operating system interface of the RPA player without using an interactive channel. The test execution management module is used to aggregate all the RPA automated test scripts, create OPR project files, and execute automated tests based on the OPR project files.

6. The system of claim 5, wherein, The RPA script creation module includes: The script file management submodule is used to create an RPA automated test script within the test workspace folder; The hierarchical editing submodule is used to define and configure one or more test processes, each containing one or more test steps, to collectively form the RPA automated test script; The benchmark file generation submodule is used to execute the RPA automated test script to generate a test verification benchmark file; The script maintenance submodule is used to modify the RPA automated test script and then re-execute it to update the test verification baseline file.

7. An electronic device, comprising: include: Memory, used to store computer programs; A processor for executing a program stored in memory to implement the steps of the method according to any one of claims 1-4.

8. A computer-readable storage medium, characterized in that, The computer readable storage medium stores a computer program, and the computer program is executed by the processor to implement the method steps in any one of claims 1-4.

Images