Geometric modeling engine testing method and device based on extensible parameters

Abstract

The embodiment of the invention provides a geometric modeling engine testing method and device based on extensible parameters, and relates to the technical field of software test.The method comprises the steps that in response to a command input operation for a command interface layer, a modeling testing command corresponding to the command input operation is determined, the modeling test command is a command in a first programming language form, and the modeling test command at least comprises geometric modeling operation and a first model parameter corresponding to the geometric modeling operation; the first model parameters are converted into second model parameters matched with a geometric modeling engine through a command interface layer, the second model parameters are transmitted into the geometric modeling engine through a parameter transmission inlet, and the second model parameters are parameters in a second programming language form; and executing the geometric modeling operation according to the second model parameter, and in response to the completion of execution of the geometric modeling operation, presenting an execution result corresponding to the geometric modeling operation in the control interface, thereby improving the test efficiency.

Description

Technical Field

[0001] The present invention relates to the technical field of software testing, and particularly to a test method for a geometric modeling engine based on extensible parameters, a test device for a geometric modeling engine based on extensible parameters, an electronic device, and a computer-readable storage medium. Background Art

[0002] In CAD (Autodesk Computer Aided Design) industrial software, the geometric modeling engine is the core part of the software, responsible for handling all geometric calculations and data management. Among them, the testing of the functions and performance of the geometric modeling engine is even more crucial. Through testing, the accuracy and efficiency of the software in dealing with complex geometric problems can be effectively ensured. However, in the process of testing the geometric modeling engine, there are problems such as low testing efficiency, lack of usability, poor scalability, and insufficient flexibility. Summary of the Invention

[0003] Embodiments of the present invention provide a test method and device for a geometric modeling engine based on extensible parameters to solve or partially solve the problems of low testing efficiency, lack of usability, poor scalability, and insufficient flexibility in the process of testing the geometric modeling engine.

[0004] Embodiments of the present invention disclose a test method for a geometric modeling engine based on extensible parameters, which is applied to a geometric modeling engine, and a test script is deployed in the geometric modeling engine; wherein, the test script at least includes a command interface layer, and the command interface layer provides a parameter passing entry for the geometric modeling engine. The method includes:

[0005] In response to a command input operation for the command interface layer, determining a modeling test command corresponding to the command input operation, the modeling test command being a command in the form of a first programming language, and the modeling test command at least including a geometric modeling operation and a first model parameter corresponding to the geometric modeling operation;

[0006] Converting the first model parameter into a second model parameter adapted to the geometric modeling engine through the command interface layer, and passing the second model parameter into the geometric modeling engine through the parameter passing entry, the second model parameter being a parameter in the form of a second programming language;

[0007] Performing the geometric modeling operation according to the second model parameter, and in response to the completion of the execution of the geometric modeling operation, presenting an execution result corresponding to the geometric modeling operation in the control interface.

[0008] In some feasible implementation manners, several command classes are encapsulated in the command interface layer. The command classes are classes encapsulated using a second programming language. The command interface layer includes operation entrances corresponding to the respective command classes, and the operation entrances are displayed in the control interface of the test script. Converting the first model parameters into second model parameters adapted to the geometric modeling engine through the command interface layer includes:

[0009] Determine a target operation entrance corresponding to the command input operation;

[0010] Select a target command class that matches the target operation entrance from the command classes. The target command class includes at least target member variables and target member functions;

[0011] Convert the first model parameters into second model parameters adapted to the geometric modeling engine according to the target member variables and target member functions.

[0012] In some feasible implementation manners, a general base class is included in the test script. The general base class is at least used to activate the command classes, deactivate the command classes, and record the execution process of the command classes. Among them, the command classes inherit the general base class, and the command classes include at least member variables and member functions.

[0013] In some feasible implementation manners, the member variables include at least one of a geometric object currently in effect and model parameters required for executing a modeling test command;

[0014] The member functions include at least one of a constructor, a destructor, a geometric operation instruction parameter setting function, and a calling function.

[0015] In some feasible implementation manners, converting the first model parameters into second model parameters adapted to the geometric modeling engine according to the target member variables and target member functions includes:

[0016] Activate the target command class through the general base class, and convert the first model parameters into second model parameters adapted to the geometric modeling engine according to the target member variables and target member functions in the target command class.

[0017] In some feasible implementation manners, before executing the geometric modeling operation according to the second model parameters, the method further includes:

[0018] If it is detected that at least one parameter of the second model parameters is abnormal, output abnormal feedback information and abnormal correction information for the second model parameters;

[0019] If no parameter anomaly is detected in the second model parameter, the second model parameter is passed into the geometric modeling engine.

[0020] In some feasible implementation manners, if at least one parameter anomaly is detected in the second model parameter, abnormal feedback information and abnormal correction information for the second model parameter are output, including:

[0021] Obtain the target parameter quantity and target parameter type corresponding to the second model parameter;

[0022] If the second model parameter fails to match the geometric modeling operation, parameter error information and parameter correction information for the second model parameter are output;

[0023] If the target parameter quantity of the second model parameter does not conform to the parameter quantity required by the geometric modeling operation, parameter quantity anomaly information and correct quantity information for the second model parameter are output;

[0024] If the target parameter type of the second model parameter does not conform to the parameter type required by the geometric modeling operation, parameter type anomaly information and correct type information for the second model parameter are output.

[0025] An embodiment of the present invention also discloses a geometric modeling engine test device based on extensible parameters, which is applied to a geometric modeling engine, and a test script is deployed in the geometric modeling engine; wherein, the test script at least includes a command interface layer, and the command interface layer provides a parameter passing entry for the geometric modeling engine, and the device includes:

[0026] A command determination module, configured to determine a modeling test command corresponding to the command input operation in response to a command input operation for the command interface layer, the modeling test command being a command in the form of a first programming language, and the modeling test command at least including a geometric modeling operation and a first model parameter corresponding to the geometric modeling operation;

[0027] A parameter processing module, configured to convert the first model parameter into a second model parameter adapted to the geometric modeling engine through the command interface layer, and pass the second model parameter into the geometric modeling engine through the parameter passing entry, the second model parameter being a parameter in the form of a second programming language;

[0028] An execution module, configured to execute the geometric modeling operation according to the second model parameter, and present an execution result corresponding to the geometric modeling operation in the control interface in response to the completion of the execution of the geometric modeling operation.

[0029] In some feasible implementation manners, several command classes are encapsulated in the command interface layer. The command classes are classes encapsulated using a second programming language. The command interface layer includes operation entrances corresponding to the respective command classes, and the operation entrances are displayed in the control interface of the test script. The parameter processing module is specifically configured to:

[0030] Determine a target operation entrance corresponding to the command input operation;

[0031] Select a target command class that matches the target operation entrance from the command classes. The target command class includes at least a target member variable and a target member function;

[0032] Convert the first model parameter into a second model parameter adapted to the geometric modeling engine according to the target member variable and the target member function.

[0033] In some feasible implementation manners, the test script includes a general base class, which is at least used to activate the command class, deactivate the command class, and record the execution process of the command class. Among them, the command class inherits the general base class, and the command class includes at least a member variable and a member function.

[0034] In some feasible implementation manners, the member variable includes at least one of a currently acting geometric object and model parameters required for executing a modeling test command;

[0035] The member function includes at least one of a constructor, a destructor, a geometric operation instruction parameter setting function, and a call function.

[0036] In some feasible implementation manners, the parameter processing module is specifically configured to:

[0037] Activate the target command class through the general base class, and convert the first model parameter into a second model parameter adapted to the geometric modeling engine according to the target member variable and the target member function in the target command class.

[0038] In some feasible implementation manners, the device further includes:

[0039] A detection module, configured to output an exception feedback message and an exception correction message for the second model parameter if it detects that there is at least one parameter exception in the second model parameter;

[0040] A transmission module, configured to pass the second model parameter into the geometric modeling engine if it does not detect that there is the parameter exception in the second model parameter.

[0041] In some feasible implementation manners, the detection module is specifically configured to:

[0042] Obtain the target parameter quantity and target parameter type corresponding to the second model parameter;

[0043] If the second model parameter fails to match the geometric modeling operation, output parameter error information and parameter correction information for the second model parameter;

[0044] If the target parameter quantity of the second model parameter does not meet the parameter quantity required by the geometric modeling operation, output parameter quantity exception information and correct quantity information for the second model parameter;

[0045] If the target parameter type of the second model parameter does not meet the parameter type required by the geometric modeling operation, output parameter type exception information and correct type information for the second model parameter.

[0046] An embodiment of the present invention also discloses an electronic device, including a processor, a communication interface, a memory, and a communication bus. Among them, the processor, the communication interface, and the memory complete communication with each other through the communication bus;

[0047] The memory is used to store a computer program;

[0048] When the processor is used to execute the program stored on the memory, the method described in the embodiment of the present invention is implemented.

[0049] An embodiment of the present invention also discloses a computer-readable storage medium, on which instructions are stored. When executed by one or more processors, the processor is caused to execute the method described in the embodiment of the present invention.

[0050] The embodiment of the present invention has the following advantages:

[0051] In an embodiment of the present invention, when a user tests the relevant geometric modeling functions of a geometric modeling engine, a corresponding test script can be deployed in the geometric modeling engine. The test script can include a command interface layer, and the command interface layer provides a parameter passing entry for the geometric modeling engine. Then, in response to a command input operation for the command interface layer, a modeling test command corresponding to the command input operation can be determined. The modeling test command is a command in the form of a first programming language, and the modeling test command at least includes a geometric modeling operation and a first model parameter corresponding to the geometric modeling operation. The first model parameter is converted into a second model parameter adapted to the geometric modeling engine through the command interface layer, and the second model parameter is passed into the geometric modeling engine through the parameter passing entry. The second model parameter is a parameter in the form of a second programming language. Then, the geometric modeling operation is executed according to the second model parameter, and in response to the completion of the execution of the geometric modeling operation, the execution result corresponding to the geometric modeling operation is presented in the control interface. Thus, in the process of testing the geometric modeling engine, by developing a corresponding test script, the testing difficulty of the geometric modeling engine is reduced. At the same time, by passing in multiple test parameters through the modeling test command, the verification and testing of the geometric modeling operation can be realized, and the parameter passing of variable parameters is supported based on the parameter passing entry, which simplifies the writing process of the geometric modeling engine test instructions and improves the generality and scalability of the test script. BRIEF DESCRIPTION OF THE DRAWINGS

[0052] Figure 1 is a flowchart of the steps of a method for testing a geometric modeling engine based on extensible parameters provided in an embodiment of the present invention;

[0053] Figure 2 is a schematic flowchart of an application scenario provided in an embodiment of the present invention;

[0054] Figure 3 is a schematic structural diagram of a test script provided in an embodiment of the present invention;

[0055] Figure 4 is a block diagram of the structure of a device for testing a geometric modeling engine based on extensible parameters provided in an embodiment of the present invention. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0056] In order to make the above objects, features, and advantages of the present invention more obvious and understandable, the present invention will be further described in detail below with reference to the accompanying drawings and specific embodiments.

[0057] As an example, during the testing of a geometric modeling engine, corresponding test cases need to be designed to test the geometric modeling engine. However, during the process of involving test cases, due to the relatively complex syntax of programming languages, it may be difficult for testers to implement. Testers need to spend a lot of time and effort to familiarize themselves with the syntax and features of programming languages, thus increasing the time cost of writing test cases and reducing the testing efficiency of the geometric modeling engine. In addition, when adding new test interfaces, the corresponding test instruction set needs to be extended, which requires developers to continuously learn new instructions. At the same time, when facing certain specific test scenarios, it may also be necessary to manually adjust the existing test cases. This approach not only limits the scalability of the test framework but also lacks necessary friendliness.

[0058] In response to this, in the present invention, when a user tests the relevant geometric modeling functions of a geometric modeling engine, a corresponding test script can be deployed in the geometric modeling engine. The test script can include a command interface layer, and the command interface layer provides a parameter passing entry for the geometric modeling engine. Then, in response to a command input operation for the command interface layer, a modeling test command corresponding to the command input operation can be determined. The modeling test command is a command in the form of a first programming language, and the modeling test command at least includes a geometric modeling operation and a first model parameter corresponding to the geometric modeling operation. The first model parameter is converted into a second model parameter adapted to the geometric modeling engine through the command interface layer, and the second model parameter is passed into the geometric modeling engine through the parameter passing entry. The second model parameter is a parameter in the form of a second programming language. Then, the geometric modeling operation is executed according to the second model parameter, and in response to the completion of the execution of the geometric modeling operation, the execution result corresponding to the geometric modeling operation is presented in the control interface. Thus, during the process of testing the geometric modeling engine, by developing a corresponding test script, the testing difficulty of the geometric modeling engine is reduced. At the same time, by passing multiple test parameters through the modeling test command, the verification and testing of the geometric modeling operation can be achieved, and the parameter passing of variable parameters is supported based on the parameter passing entry, simplifying the writing process of the geometric modeling engine test instructions and improving the generality and scalability of the test script.

[0059] Referring to Figure 1 , a step flowchart of a method for testing a geometric modeling engine based on extensible parameters provided in an embodiment of the present invention is shown. The method is applied to a geometric modeling engine, and a test script is deployed in the geometric modeling engine. The test script at least includes a command interface layer, and the command interface layer provides a parameter passing entry for the geometric modeling engine. Specifically, the following steps may be included:

[0060] Step 101, in response to a command input operation for the command interface layer, determine a modeling test command corresponding to the command input operation. The modeling test command is a command in the form of a first programming language and at least includes geometric modeling operations and first model parameters corresponding to the geometric modeling operations.

[0061] For a geometric modeling engine, it can be a software library or tool for creating, editing, and analyzing geometric models (such as cuboids, cylinders, spheres, etc.). For example, it can be used for the creation and editing of geometric bodies, Boolean operations (such as union, difference, and intersection, etc.), transformation of geometric bodies (such as translation, rotation, scaling, etc.), and calculation of geometric body properties (such as volume, surface area, etc.).

[0062] Among them, in order to ensure that the geometric modeling engine can accurately and efficiently process complex geometric elements and functions, before formally performing geometric modeling, the user can first perform functional tests on relevant geometric modeling functions in the geometric modeling engine to verify whether the geometric modeling functions of the geometric modeling engine can work as expected, so as to discover defects and errors existing in the modeling functions, etc., and ensure the accuracy of the model objects constructed during the modeling process and the reliability of the functions.

[0063] In the embodiments of the present invention, in order to test and verify the functions, performance, etc. of the geometric modeling engine, corresponding test scripts can be constructed, and the functions, performance, etc. of the geometric modeling engine can be tested and verified based on the test scripts to ensure the correctness and stability when the geometric modeling engine executes geometric operations.

[0064] Among them, for the test script, it can at least include a command interface layer. The command interface layer can be used to receive parameters input by the user in the test script, analyze, convert the user-input parameters, and call the API (Application Programming Interface) interface of the geometric modeling engine for parameter transfer, etc. In addition, during the process of running the test script, a control interface corresponding to the test script can also be displayed in the interaction interface of the geometric modeling engine, and corresponding operation entries can be provided in the control interface. Different operation entries can be used to input different modeling test commands, etc. Thus, by constructing corresponding test scripts, the test of the geometric modeling engine can be realized through the test scripts, which can reduce the test difficulty of the geometric modeling engine.

[0065] It should be noted that for the test script, it can be a script developed based on the Python programming language. At the same time, during the development process, for specific structures in the script, the C++ programming language can also be combined for writing. Thus, the test script is developed based on the Python programming language, making full use of the concise and efficient characteristics of the Python programming language syntax to quickly write and execute the test script, greatly reducing the test difficulty of the geometric modeling engine. At the same time, the C++ programming language is combined to write specific interfaces, effectively improving the generality and compatibility of the test script. Optionally, during the test, the tester can input test instructions in Python form, set corresponding test parameters, and then call the underlying C++ interface to operate on the geometric model to achieve the test of the geometric modeling engine.

[0066] For example, the main test logic of the test script can be written in Python, and for specific geometric modeling and geometric constraint commands, they can be encapsulated as corresponding command classes in the C++ programming language, so as to implement corresponding geometric modeling and geometric constraint commands based on the encapsulated command classes. The present invention is not limited thereto.

[0067] In some feasible implementation manners, for the test script, it can be a general command call of RunCommand encapsulated based on the interface provided by the Python C API, enabling it to call the underlying C++ interface to achieve the test and verification of the functional performance of the geometric modeling engine, ensuring the correctness and stability of geometric operations. In a specific implementation, the test script can include a basic interface (i.e., a control interface for providing an input entry for editing instructions to the user, displaying the execution interfaces corresponding to the modeling test commands, etc.), project dependency libraries (such as Python.dll, Command.dll, etc.), and an API interface layer of the geometric modeling engine. Among them, the project dependency libraries and the API interface layer can form the command interface layer of the test script. Through the mutual cooperation between the control interface and the command interface layer, the test parameters for testing the geometric modeling engine can be determined, and the interfaces of the geometric modeling engine can be called to transfer parameters, so as to import the corresponding test parameters into the geometric modeling engine for testing.

[0068] In some examples, since the test script can be developed for the interfaces provided by the Python C API, a general command call named RunCommand can be built in the C++ interface layer, and this function accepts variable parameter types. Among them, for the variable parameter types, they can accept parameters of different lengths or different types. For example, RunCommand("box", length, width, height) receives the modeling instruction "box" and three numerical values, representing generating a cuboid with the specified length, width, and height at the origin; RunCommand("box", Point1, length, width, height), in addition to receiving "box" and three numerical values, also receives a point parameter additionally, representing generating a cuboid with the specified length, width, and height at the specified point position as input parameters. The main purpose is to receive the parameter values and their quantities provided by the user.

[0069] In the test script, a common base class CmdBase of the command class can also be defined. In this base class, the virtual function mechanism is applied to define the common operations of subsequent command classes, such as command activation, command cancellation, execution process recording, etc. At the same time, specific geometric modeling and geometric constraint commands are encapsulated into a corresponding command class with C++ code. This command class needs to inherit the defined common base class CmdBase to implement the virtual methods in the common base class, and at the same time, a core function of the geometric modeling engine is encapsulated in it, such as creating geometric entities, editing geometric shapes, querying geometric data, etc. Among them, the member variables included in this command class mainly include the geometric object currently in effect, the parameters required for the current command, etc. The main components of the member functions include construction, destruction, geometric operation instruction parameter setting, and methods for calling interfaces. In the methods for calling interfaces, the encapsulated kernel API interfaces need to be called.

[0070] Through the above process, the development of the test script can be realized. During the process of testing the geometric modeling engine through the test script, testers can input corresponding modeling test commands in the test script. The editor of the test script reads the modeling test commands (i.e., RunCommand instructions), sets the corresponding input parameters, and then calls the underlying kernel API interface to operate on the geometric model to achieve the functional test of the geometric modeling engine.

[0071] During the process of testing the geometric modeling engine, testers can input corresponding command input operations based on the test script. The test script determines the corresponding modeling test commands based on the command input operations. Among them, the modeling test commands can be commands in the form of a first programming language, and the modeling test commands at least include geometric modeling operations and first model parameters corresponding to the geometric modeling operations. Among them, the geometric modeling operation is used to indicate what kind of modeling operation the geometric modeling engine performs, such as creating geometric objects, editing geometric objects, etc. The first model parameter can be a parameter in the form of the first programming language. Optionally, the first programming language can be Python. Then, testers can input test commands in Python form, which are converted by the test script into test commands in C++ form, so that the geometric modeling engine can perform corresponding geometric modeling operations according to the C++-form parameters to achieve the testing of the geometric modeling engine.

[0072] Step 102, convert the first model parameter into a second model parameter adapted to the geometric modeling engine through the command interface layer, and pass the second model parameter into the geometric modeling engine through the parameter passing entry. The second model parameter is a parameter in the form of a second programming language.

[0073] After the tester inputs the corresponding geometric modeling operation in the control interface provided by the test script, the test script can determine the modeling test command corresponding to the geometric modeling operation. Then, it converts the first model parameter in the modeling test command into a second model parameter adapted to the geometric modeling engine through the command interface layer, and passes the second model parameter into the geometric modeling engine through the parameter passing entry, so that the geometric modeling engine can perform corresponding geometric modeling operations according to the second model parameter. Among them, the second model parameter is a parameter in the form of a second programming language. Optionally, the second programming language can be C++.

[0074] It should be noted that for test users, inputting test commands based on the Python programming language can effectively reduce the test difficulty. For the geometric modeling engine, the operation of its underlying code can be based on the C++ programming language. During the testing process, it is necessary to convert the Python-form test parameters into C++-form test parameters for execution in the geometric modeling engine.

[0075] In some feasible implementation manners, in the development process of the above test script, several command classes can be encapsulated in the command interface layer. The command classes are classes encapsulated using a second programming language. The command interface layer includes operation entrances corresponding to each command class, and the operation entrances are displayed in the control interface of the test script. Then the process of parameter conversion can include: First, determine the target operation entrance corresponding to the command input operation; Next, select the target command class that matches the target operation entrance from the command classes. The target command class includes at least target member variables and target member functions; Then, convert the first model parameters into second model parameters adapted to the geometric modeling engine according to the target member variables and target member functions.

[0076] Among them, the test script includes a general base class, and the general base class is at least used to activate command classes, deactivate command classes, call the command interface layer, and record the execution process of command classes; Among them, the command classes inherit from the general base class, and the command classes include at least member variables and member functions. In addition, the member variables include at least one of the geometric objects currently in effect and the model parameters required for executing the modeling test commands; The member functions include at least one of a constructor, a destructor, a geometric operation instruction parameter setting function, and a call function.

[0077] In a specific implementation, the target command class can be activated first through the general base class, and then the first model parameters are converted into second model parameters adapted to the geometric modeling engine according to the target member variables and target member functions in the target command class. For example, the command classes are used to define different geometric operations, including but not limited to operations such as creating a cuboid, a sphere, offset, rotation, intersection, union, fillet, chamfer, combination, etc. Correspondingly, the operation entrances corresponding to different command classes can be displayed in the control interface of the test script. During the test, assume that the tester selects "create a cuboid" and sets the corresponding model parameters. Then the test script can determine the corresponding RunCommand command ("box", length, width, height), and then activate the corresponding target command class (the command class for creating a cuboid) through the common base class, and convert model parameters such as length, width, and height into model parameters adapted to the geometric modeling engine according to the target member variables and target member functions included in the target command class, such as converting Python-form parameters into C++-form parameters, etc., so as to subsequently pass the C++-form parameters to the geometric modeling engine through the API interface of the geometric modeling engine for functional testing. Thus, during the test, by supporting variable parameter passing when calling the RunCommand interface, the writing process of the geometric modeling engine test instructions can be effectively simplified, and the generality and scalability are effectively improved.

[0078] Step 103, perform the geometric modeling operation according to the second model parameter, and in response to the completion of the geometric modeling operation, present the execution result corresponding to the geometric modeling operation in the control interface.

[0079] After the test script converts the model parameter into the second model parameter adapted to the geometric modeling engine, the second model parameter can be passed to the geometric modeling engine through the parameter passing entry provided by the command interface layer, so that the geometric modeling engine can perform the corresponding geometric modeling operation according to the second model parameter, and thus judge whether the geometric modeling engine can perform the corresponding geometric modeling operation as expected according to the execution result corresponding to the geometric modeling operation performed by the geometric modeling engine. Therefore, in the process of testing the geometric modeling engine, by developing the corresponding test script, the test difficulty of the geometric modeling engine can be reduced. At the same time, by passing in multiple test parameters through the modeling test command, the verification and test of the geometric modeling operation can be realized, and based on the parameter passing entry supporting variable parameter passing, the writing process of the geometric modeling engine test instruction is simplified, and the generality and scalability of the test script are improved.

[0080] In some feasible implementation manners, before passing the second model parameter to the geometric modeling engine for functional testing, the second model parameter can also be first subjected to error detection to judge whether the second model parameter is a correct and executable model parameter. Specifically, before performing the geometric modeling operation according to the second model parameter, it can be first detected whether there is a parameter exception in the second model parameter. If it is detected that there is at least one parameter exception in the second model parameter, the exception feedback information and the exception correction information for the second model parameter are output; if it is not detected that there is the parameter exception in the second model parameter, the second model parameter is passed into the geometric modeling engine.

[0081] Among them, in the test script, an enumeration can be defined for possible parameter exceptions. The elements of the enumeration should at least include parameter normal, inconsistent parameter quantity, and incorrect parameter type, etc. Inconsistent parameter quantity means that the number of parameters required for the executed geometric modeling operation is inconsistent with the number of actual model parameters passed in, while incorrect parameter type means that the parameter type required for the executed geometric modeling operation is inconsistent with the parameter type of the actual model parameters passed in. In specific implementation, the target parameter quantity and target parameter type corresponding to the second model parameter can be obtained first, and then the model parameters can be detected according to the target parameter quantity and target parameter type. If the second model parameter fails to match the geometric modeling operation, the parameter error information and parameter correction information for the second model parameter are output; if the target parameter quantity of the second model parameter does not meet the parameter quantity required by the geometric modeling operation, the parameter quantity exception information and the correct quantity information for the second model parameter are output; if the target parameter type of the second model parameter does not meet the parameter type required by the geometric modeling operation, the parameter type exception information and the correct type information for the second model parameter are output. Thus, when an exception is detected, the corresponding parameter exception information and parameter correction information are output, enabling users to efficiently and intuitively perceive the corresponding exception, which is conducive to discovering potential risks in parameter parsing.

[0082] For example, to create a cuboid RunCommand(“box”, Length, Width, Height), “box” represents the modeling operation, and the three values of Length, Width, and Height represent the length, width, and height respectively. If the call parameters are correct, the returned parameter is normal. However, if an additional numerical parameter Value5 is passed in when calling the function RunCommand(“box”, Length, Width, Height, Value5), the parameter length is inconsistent with the expectation, and the error can be detected in the command class, returning an error indicating inconsistent parameter quantity. Another example is RunCommand(“box”, Point, Length, Width, Height), which creates a cuboid with length Length, width Width, and height Height at point Point. If the call parameters are correct, the returned parameter is normal. But if the passed parameter is RunCommand(“box”, Vector, Length, Width, Height), and the parameter of Vector should originally be a point parameter but is now a vector parameter, which is inconsistent with the expected parameter type, the function will return an incorrect parameter type.

[0083] After completing the error detection of the parameters, if the second model parameters are correct, the corresponding second model parameters can be passed into the geometric modeling engine. The geometric modeling engine can perform geometric modeling operations according to the second model parameters, and in response to the completion of the geometric modeling operations, present the execution results corresponding to the geometric modeling operations in the control interface. Thus, during the process of testing the geometric modeling engine, by developing corresponding test scripts, the testing difficulty of the geometric modeling engine can be reduced. At the same time, by passing in multiple test parameters through the modeling test commands, the verification and testing of the geometric modeling operations can be achieved, and the passing of variable parameters is supported based on the parameter passing entry, simplifying the writing process of the geometric modeling engine test instructions and improving the generality and scalability of the test scripts.

[0084] It should be noted that the embodiments of the present invention include but are not limited to the above examples. It can be understood that those skilled in the art can also make settings according to actual needs under the guidance of the ideas of the embodiments of the present invention, and the present invention does not limit this.

[0085] In the embodiments of the present invention, when a user tests the relevant geometric modeling functions of the geometric modeling engine, corresponding test scripts can be deployed in the geometric modeling engine. The test scripts can include a command interface layer, and the command interface layer provides a parameter passing entry for the geometric modeling engine. Then, in response to a command input operation for the command interface layer, a modeling test command corresponding to the command input operation can be determined. The modeling test command is a command in the form of a first programming language, and the modeling test command at least includes a geometric modeling operation and a first model parameter corresponding to the geometric modeling operation. The first model parameter is converted into a second model parameter adapted to the geometric modeling engine through the command interface layer, and the second model parameter is passed into the geometric modeling engine through the parameter passing entry. The second model parameter is a parameter in the form of a second programming language. Then, the geometric modeling operation is performed according to the second model parameter, and in response to the completion of the geometric modeling operation, the execution results corresponding to the geometric modeling operation are presented in the control interface. Thus, during the process of testing the geometric modeling engine, by developing corresponding test scripts, the testing difficulty of the geometric modeling engine can be reduced. At the same time, by passing in multiple test parameters through the modeling test commands, the verification and testing of the geometric modeling operations can be achieved, and the passing of variable parameters is supported based on the parameter passing entry, simplifying the writing process of the geometric modeling engine test instructions and improving the generality and scalability of the test scripts.

[0086] To enable those skilled in the art to better understand the technical solutions in the embodiments of the present invention, the following provides exemplary descriptions through corresponding examples:

[0087] In the following examples, the corresponding meanings of the technical features involved are as follows:

[0088] The Chinese meaning of Var is: variable name

[0089] The Chinese meaning of Func is: function name

[0090] The Chinese meaning of Array is: array type

[0091] The Chinese meaning of InParam is: input parameter

[0092] The Chinese meaning of OutParam is: output parameter

[0093] The Chinese meaning of Res is: instruction execution result

[0094] The Chinese meaning of Geom_Command is: geometric operation instruction

[0095] As an example, referring to Figure 2 , a flow schematic diagram of the application scenario provided in the embodiments of the present invention is shown. For the usage process of the test script, it may include: RunCommand command call - modeling command matching - modeling parameter parsing - geometric engine interface call - execution result range, etc.

[0096] Specifically, by designing a command interface layer in the test script that can call the APIs in the geometric modeling engine, the main function of this command interface layer is to encapsulate and abstract the operations of the relevant geometric modeling engine, so as to be able to be called in the way of the RunCommand command class.

[0097] In a specific implementation, a general base class named CmdBase can be constructed in the test script. This base class integrates the interfaces of the basic command execution process, covering basic functions such as activation, deactivation, middle - layer interface call, and logging during the command execution process. Based on this base class, command classes for performing diverse operations are further defined, including but not limited to operations such as creating a cuboid, sphere, offset, rotation, intersection, union, fillet, chamfer, combination, etc. Such classes need to inherit from the CmdBase base class, and override the process methods in the base class in the derived class. Then, the results of encapsulating and abstracting the operations of the relevant geometric modeling engine designed in the foregoing process and the current series of command classes are encapsulated into a dynamic library Command.dll. At the same time, Python.dll can be introduced, and a Python extension module is written using Python's C API. This module can convert Python instructions into calls to C++ interfaces. A RunCommand generalization command is implemented in the Python extension module. This command can receive the Python instructions input by the user and convert them into corresponding C++ interface calls. For example, the user can input a simple RunCommand instruction for creating a cuboid according to the established format requirements, and the corresponding result can be seen after executing this command.

[0098] For the general command call format of RunCommand, it is still essentially a function call, and the corresponding C++ implementation is called through the geometric operation instructions in Python form input by the user. Therefore, the present invention redefines the data types of InParam in the RunCommand command, mainly including:

[0099] ① String: Type_String;

[0100] ② Integer: Type_Int;

[0101] ③ Floating point type: Type_Double;

[0102] ④ Vector: Type_Vevtor(Type_Doubled1,Type_Doubled2,Type_Doubled3);

[0103] ⑤ Coordinate point: Type_Point(Type_Double x1,Type_Double y1,Type_Double z1).

[0104] Optionally, the redefinition is for expansion to make it more suitable for testing the geometric modeling engine. First, redefine the existing types: for example, redefine the string class as Type_String, and the behavior of the string can be redefined, such as Type_String can be directly concatenated with Type_Point. Second, define the data structures that do not originally exist in Python, and more data structures suitable for testing the geometric modeling engine can be customized, such as Type_BoundBox, which represents the model bounding box.

[0105] Regarding the call of the RunCommand command, it still needs to follow the syntax of the Python scripting language. When defining variables, it is not necessary to write out their data types. For example, in Example Code I, when defining the variable Var_1 and directly assigning it the value 10, Python will default to interpreting it as an integer type. In Example Code II, when defining the variable Array_1, which is an array type variable, for such variables, the data types of variables or values can be directly defined in square brackets and then assigned to the corresponding array variable.

[0106] Example Code I: Var_1 = 10

[0107] Example Code II: Array_1 = [0,1,2,3]

[0108] Note: It should be noted here that there is no need to add a semicolon at the end of each line of code

[0109] Based on the relevant declarations in the above process, and since the application of RunCommand is essentially a function call, it is necessary to pass parameters to it. Taking Example Code III as an example, the general command parameters of RunCommand are described as follows:

[0110] The RunCommand command is equivalent to the function name Func in C++.

[0111] The first parameter Geom_Command_1 is a geometric operation instruction of Type_String type, representing the geometric operation that the user expects to execute, which can be importing a model file, creating an entity, geometric transformation, complex topology, etc.

[0112] The second parameter Res is usually the receiving object of the execution result of this operation instruction (it should be noted that there can be corresponding special cases. For example, for the command to import a model, the second parameter is the full name of the model, and the third parameter is the receiving object for importing the model), that is, the return value. The user can understand it as the variable on the left side of the assignment operator, and it is also of Type_String type. Additionally, it should be noted that this is also the difference between the RunCommand command call and a general function call. Usually, the return value of a general function is outside the function call statement, while the execution result of the RunCommand command is inside the call statement.

[0113] The third parameter InParam_1 can have various situations. It may be a numerical type or a geometric object, and it needs to be specifically analyzed according to the instruction type. For example, when creating a cuboid object, InParam_1 is an integer type, representing the length of the cuboid to be created. However, when performing an intersection on two geometric entities, InParam_1 is the name of one of the entity objects. The subsequent parameters InParam2... are similar to the third parameter, and no more details will be elaborated here.

[0114] Example Code III: RunCommand(Geom_Command_1, Res, InParam_1, InParam_2,...)

[0115] Based on the above parameter description, it is verified from the side that the RunCommand command in the present invention supports passing multiple parameters, and for specific geometric operation instructions Geom_Command, the parameter types and the number of parameters may be different in different scenarios.

[0116] Meanwhile, a error-checking feedback mechanism is provided during the invocation of the RunCommand command. First, an enumeration is defined according to possible error scenarios, and the specific enumeration elements include normal parameters, inconsistent number of parameters, and incorrect parameter type. The specific implementation method is to perform error checking on the input parameters in each command class at the C++ interface layer. First, the number of input parameters is checked. If the number of parameters does not meet the requirements of the geometric operation instruction, an error message is called, returning an error of inconsistent number of parameters, and at the same time, the correct number of parameters is fed back. Subsequently, each input parameter is checked one by one. In this link, it is mainly checked whether the parameter type meets the expected type. For example, if an integer type is expected, but a string type is actually passed in. If a vector type is expected and a coordinate point type is passed in, etc., all of these will cause an error in the command call, returning an error of incorrect parameter type, and the expected correct data type is returned for the current parameter.

[0117] After the error checking is completed, the corresponding intermediate layer interface can be called to return the corresponding execution result, so as to implement the testing and verification of the relevant geometric kernel.

[0118] In summary, the test method for the extensible and variable parameter geometric modeling engine provided in this embodiment simplifies the writing process of a test case and improves the efficiency of geometric kernel testing and verification by reusing the RunCommand command and making standardized requirements for the format of the called geometric operation command and input parameters, providing the possibility for subsequent automated test case writing compared with the prior art.

[0119] Correspondingly, referring to Figure 3 , a schematic structural diagram of the test script provided in the embodiment of the present invention is shown. Specifically, for the UI interface layer, a command editing module that can be manually operated by the user can be included in the test script. This module provides basic functions such as clearing commands, loading the previous command, and executing commands.

[0120] For the command interface layer, the system adopts the object-oriented design principle, and encapsulates each geometric operation (geometric operations include modeling operations supported by the geometric modeling engine, such as creating basic bodies (cuboids, cylinders, etc.), geometric transformations (translation, rotation, scaling, etc.), feature modeling (such as stretching, sweeping, chamfering, etc.)) into an independent command class. These command classes follow a unified interface design, ensuring high cohesion and low coupling between classes. Each class implements standardized and templated public interfaces such as activation and cancellation. At the same time, each command class also contains relevant methods for setting its own attributes (its own attributes include flags such as whether the command execution is cancelled and whether it fails, and relevant methods include command rollback methods, re-execution methods, etc.). These methods allow users to adjust the parameters of geometric operations according to specific needs, thus providing a high degree of flexibility and customization.

[0121] In addition, to improve the scalability and compatibility of the test script, the command interface layer further includes a geometric modeling engine API layer, which provides a unified call entry through the geometric modeling engine API layer, encapsulates the underlying API interface calls of the geometric kernel, thereby not only improving the generality of the software, but also facilitating future possible technology upgrades and kernel replacements, and ensuring the scalability and compatibility of the test script.

[0122] In summary, in this example, in the design of the UI interface layer and the command interface layer, through the designed modular structure and interfaces, the flexibility, maintainability and scalability of the test script are ensured, providing users with powerful geometric operation capabilities, and at the same time laying a good expansion foundation for the iterability of the test script.

[0123] It should be noted that for the method embodiments, for simplicity of description, they are all expressed as a series of action combinations. However, those skilled in the art should know that the embodiments of the present invention are not limited by the described action sequences, because according to the embodiments of the present invention, certain steps can be performed in other sequences or simultaneously. Secondly, those skilled in the art should also know that the embodiments described in the specification are all preferred embodiments, and the actions involved are not necessarily essential for the embodiments of the present invention.

[0124] Referring to Figure 4 , a structural block diagram of a geometric modeling engine test device based on extensible parameters provided in an embodiment of the present invention is shown, which is applied to a geometric modeling engine, and a test script is deployed in the geometric modeling engine; wherein, the test script at least includes a command interface layer, and the command interface layer provides a parameter passing entry for the geometric modeling engine, and specifically may include the following modules:

[0125] A command determination module 401, configured to determine a modeling test command corresponding to the command input operation in response to a command input operation for the command interface layer, where the modeling test command is a command in the form of a first programming language, and the modeling test command at least includes a geometric modeling operation and a first model parameter corresponding to the geometric modeling operation;

[0126] A parameter sorting module 402, configured to convert the first model parameter into a second model parameter adapted to the geometric modeling engine through the command interface layer, and pass the second model parameter into the geometric modeling engine through the parameter passing entry, where the second model parameter is a parameter in the form of a second programming language;

[0127] An execution module 403, configured to perform the geometric modeling operation according to the second model parameter, and present an execution result corresponding to the geometric modeling operation in the control interface in response to the completion of the geometric modeling operation.

[0128] In some feasible implementation manners, a plurality of command classes are encapsulated in the command interface layer. The command classes are classes encapsulated using a second programming language. The command interface layer includes operation entrances corresponding to the respective command classes, and the operation entrances are displayed in the control interface of the test script. The parameter sorting module 402 is specifically configured to:

[0129] Determine a target operation entrance corresponding to the command input operation;

[0130] Select a target command class that matches the target operation entrance from the command classes. The target command class includes at least a target member variable and a target member function;

[0131] Convert the first model parameter into a second model parameter adapted to the geometric modeling engine according to the target member variable and the target member function.

[0132] In some feasible implementation manners, the test script includes a general base class, which is at least used to activate the command class, deactivate the command class, and record the execution process of the command class. Among them, the command class inherits the general base class, and the command class includes at least a member variable and a member function.

[0133] In some feasible implementation manners, the member variable includes at least one of a currently acting geometric object and model parameters required for performing a modeling test command;

[0134] The member function includes at least one of a constructor, a destructor, a geometric operation instruction parameter setting function, and a call function.

[0135] In some feasible implementation manners, the parameter sorting module 402 is specifically configured to:

[0136] Activate the target command class through the general base class, and convert the first model parameter into a second model parameter adapted to the geometric modeling engine according to the target member variable and the target member function in the target command class.

[0137] In some feasible implementation manners, the device further includes:

[0138] A detection module, configured to output an exception feedback message and an exception correction message for the second model parameter if at least one parameter exception is detected in the second model parameter;

[0139] A transfer module, configured to, if the parameter anomaly of the second model parameter is not detected, transmit the second model parameter to the geometric modeling engine.

[0140] In some possible implementation manners, the detection module is specifically configured to:

[0141] Obtain the target parameter quantity and target parameter type corresponding to the second model parameter;

[0142] If the second model parameter fails to match the geometric modeling operation, output parameter error information and parameter correction information for the second model parameter;

[0143] If the target parameter quantity of the second model parameter does not conform to the parameter quantity required by the geometric modeling operation, output parameter quantity anomaly information and correct quantity information for the second model parameter;

[0144] If the target parameter type of the second model parameter does not conform to the parameter type required by the geometric modeling operation, output parameter type anomaly information and correct type information for the second model parameter.

[0145] For the device embodiment, since it is basically similar to the method embodiment, the description is relatively simple. For the related parts, refer to the partial description of the method embodiment.

[0146] In addition, an embodiment of the present invention further provides an electronic device, including: a processor, a memory, and a computer program stored on the memory and executable on the processor. When the computer program is executed by the processor, it implements each process of the above-mentioned method embodiment for testing a geometric modeling engine based on extensible parameters, and can achieve the same technical effect. To avoid repetition, it will not be elaborated here.

[0147] An embodiment of the present invention further provides a computer-readable storage medium, on which a computer program is stored. When the computer program is executed by a processor, it implements each process of the above-mentioned method embodiment for testing a geometric modeling engine based on extensible parameters, and can achieve the same technical effect. To avoid repetition, it will not be elaborated here. Among them, the computer-readable storage medium, such as a read-only memory (ROM for short), a random access memory (RAM for short), a magnetic disk, or an optical disc, etc.

[0148] Each embodiment in this specification is described in a progressive manner. The key point of each embodiment is to illustrate the differences from other embodiments. The same or similar parts among the embodiments can be referred to each other.

[0149] Those skilled in the art should understand that the embodiments of the present invention can be provided as methods, apparatuses, or computer program products. Therefore, the embodiments of the present invention can take the form of all-hardware embodiments, all-software embodiments, or embodiments combining software and hardware aspects. Moreover, the embodiments of the present invention can take the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to disk memories, CD-ROMs, optical memories, EEPROMs, Flash, and eMMC, etc.) containing computer-usable program code.

[0150] The embodiments of the present invention are described with reference to the flowcharts and / or block diagrams of methods, terminal devices (systems), and computer program products according to the embodiments of the present invention. It should be understood that each flow and / or block in the flowchart and / or block diagram, as well as the combination of flows and / or blocks in the flowchart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to the processors of general-purpose computers, special-purpose computers, embedded processors, or other programmable data processing terminal devices to generate a machine, so that the instructions executed by the processors of the computer or other programmable data processing terminal devices generate a device for implementing the functions specified in Figure 1 one or more of the flows Figure 1 or multiple flows and / or blocks

[0151] These computer program instructions can also be stored in a computer-readable memory that can direct a computer or other programmable data processing terminal device to work in a specific manner, so that the instructions stored in the computer-readable memory generate a manufactured article including an instruction device, and the instruction device implements the functions specified in Figure 1 one or more of the flows Figure 1 or multiple flows and / or blocks

[0152] These computer program instructions can also be loaded onto a computer or other programmable data processing terminal device, so that a series of operation steps are executed on the computer or other programmable terminal device to generate a computer-implemented process, and thus the instructions executed on the computer or other programmable terminal device provide steps for implementing the functions specified in Figure 1 one or more of the flows Figure 1 or multiple flows and / or blocks

[0153] Although the preferred embodiments of the embodiments of the present invention have been described, those skilled in the art can make additional changes and modifications to these embodiments once they learn the basic creative concepts. Therefore, the appended claims are intended to be construed to include the preferred embodiments and all changes and modifications falling within the scope of the embodiments of the present invention.

[0154] Finally, it should also be noted that in this text, relational terms such as first and second are only used to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any actual relationship or order between these entities or operations. Moreover, the term "comprising", "including" or any other variant thereof is intended to cover non-exclusive inclusion, so that a process, method, article or terminal device comprising a series of elements not only includes those elements, but also includes other elements not expressly listed, or further includes elements inherent to such process, method, article or terminal device. Without further limitation, an element defined by the statement "comprising an..." does not exclude the presence of additional identical elements in the process, method, article or terminal device comprising the said element.

[0155] The above has introduced in detail a method for testing a geometric modeling engine based on extensible parameters and a device for testing a geometric modeling engine based on extensible parameters provided by the present invention. Specific examples are used in this text to elaborate on the principle and implementation manner of the present invention. The description of the above embodiments is only used to help understand the method and its core idea of the present invention; at the same time, for those of ordinary skill in the art, according to the idea of the present invention, there will be changes in the specific implementation manner and application scope. In summary, the content of this specification should not be construed as a limitation to the present invention.

Claims

1. A test method for a geometric modeling engine based on extensible parameters, characterized in that, Applied to a geometric modeling engine, in which a test script is deployed; wherein, the test script at least includes a command interface layer, and the command interface layer provides a parameter passing entry for the geometric modeling engine. The method includes: In response to a command input operation for the command interface layer, determining a modeling test command corresponding to the command input operation, the modeling test command being a command in the form of a first programming language, and the modeling test command at least including a geometric modeling operation and a first model parameter corresponding to the geometric modeling operation; Converting the first model parameter into a second model parameter adapted to the geometric modeling engine through the command interface layer, and passing the second model parameter into the geometric modeling engine through the parameter passing entry, the second model parameter being a parameter in the form of a second programming language; Performing the geometric modeling operation according to the second model parameter, and in response to the completion of the execution of the geometric modeling operation, presenting an execution result corresponding to the geometric modeling operation in the control interface.

2. The method according to claim 1, wherein The command interface layer encapsulates a number of command classes, the command classes being classes encapsulated using a second programming language, and the command interface layer includes operation entries corresponding to each of the command classes, and the operation entries are displayed in the control interface of the test script. The converting the first model parameter into a second model parameter adapted to the geometric modeling engine through the command interface layer includes: Determining a target operation entry corresponding to the command input operation; Selecting a target command class that matches the target operation entry from the command classes, the target command class at least including target member variables and a target member function; Converting the first model parameter into a second model parameter adapted to the geometric modeling engine according to the target member variables and the target member function.

3. The method according to claim 2, wherein The test script includes a general base class, and the general base class is at least used to activate the command classes, deactivate the command classes, and record the execution process of the command classes; wherein, the command classes inherit the general base class, and the command classes at least include member variables and member functions.

4. The method according to claim 3, wherein The member variables at least include one of a geometric object currently in effect and model parameters required for performing a modeling test command; The member functions at least include one of a constructor, a destructor, a geometric operation instruction parameter setting function, and a call function.

5. The method according to claim 3 or 4, characterized in that, The converting the first model parameter into a second model parameter adapted to the geometric modeling engine according to the target member variables and the target member function includes: Activating the target command class through the general base class, and converting the first model parameter into a second model parameter adapted to the geometric modeling engine according to the target member variables and the target member function in the target command class.

6. The method according to any one of claims 1 to 5, characterized in that, Before performing the geometric modeling operation according to the second model parameter, the method further includes: If it is detected that there is at least one parameter anomaly in the second model parameter, outputting an anomaly feedback message and an anomaly correction message for the second model parameter; If no parameter anomaly is detected in the second model parameter, the second model parameter is passed into the geometric modeling engine.

7. The method according to claim 6, wherein If at least one parameter anomaly is detected in the second model parameter, abnormal feedback information and abnormal correction information for the second model parameter are output, including: Obtain the target parameter quantity and target parameter type corresponding to the second model parameter; If the second model parameter fails to match the geometric modeling operation, parameter error information and parameter correction information for the second model parameter are output; If the target parameter quantity of the second model parameter does not meet the parameter quantity required by the geometric modeling operation, parameter quantity anomaly information and correct quantity information for the second model parameter are output; If the target parameter type of the second model parameter does not meet the parameter type required by the geometric modeling operation, parameter type anomaly information and correct type information for the second model parameter are output.

8. A geometric modeling engine test device based on extensible parameters, characterized in that, Applied to a geometric modeling engine, a test script is deployed in the geometric modeling engine; wherein, the test script at least includes a command interface layer, and the command interface layer provides a parameter passing entry for the geometric modeling engine. The device includes: A command determination module, configured to determine a modeling test command corresponding to the command input operation in response to a command input operation for the command interface layer. The modeling test command is a command in the form of a first programming language, and the modeling test command at least includes a geometric modeling operation and a first model parameter corresponding to the geometric modeling operation; A parameter processing module, configured to convert the first model parameter into a second model parameter adapted to the geometric modeling engine through the command interface layer, and pass the second model parameter into the geometric modeling engine through the parameter passing entry. The second model parameter is a parameter in the form of a second programming language; An execution module, configured to execute the geometric modeling operation according to the second model parameter, and present an execution result corresponding to the geometric modeling operation in the control interface in response to the completion of the execution of the geometric modeling operation.

9. An electronic device, characterized in that, It includes a processor, a communication interface, a memory, and a communication bus. Among them, the processor, the communication interface, and the memory complete mutual communication through the communication bus; The memory is used to store a computer program; When the processor is used to execute the program stored on the memory, it implements the method according to any one of claims 1-7.

10. A computer-readable storage medium, on which instructions are stored. When the instructions are executed by one or more processors, the processors are caused to execute the method according to any one of claims 1-7.

Images