An entity component system testing system, method, storage medium and program product

Abstract

The present invention relates to the technical field of system testing, and discloses an entity component system testing system, method, storage medium and program product. The configuration manager of the present invention responds to user-defined target test configuration parameters. The test center initializes all test executors based on the target test configuration parameters and enables the user to select a target test case. The test center integrates the corresponding relationships between each test case and the test executor. Based on the target test case set, the test of the corresponding test executor is triggered. The test executor tests the entity component system to be tested based on the target test case. By decomposing a complex system into multiple independent test units, the test complexity is greatly reduced, enabling developers to quickly and accurately locate and fix problems in the system, and significantly shortening the development and debugging cycle.

Description

Technical Field

[0001] The present invention relates to the technical field of system testing, and particularly to a system, method, storage medium and program product for testing an entity component system. Background Art

[0002] The Entity Component System (ECS) architecture is widely used in various large-scale projects. By separating data and behavior, ECS improves the scalability and performance of the system. However, with the expansion of the system scale, how to efficiently conduct tests, especially for the location of complex interactions and difficult bugs, has become a major challenge in the development process. Currently, the main testing methods for the ECS architecture are as follows:

[0003] Manual testing: Developers manually write test cases to gradually verify the system functions. However, this method is inefficient and prone to missing boundary cases; Automated unit testing: Use existing test frameworks (such as JUnit, NUnit) to conduct unit tests on components and systems. Although the testing efficiency is improved, it often falls short when dealing with complex interactions and large-scale data; Integration testing and end-to-end testing: Verify the overall system functions by simulating the complete application process. However, such tests usually take a long time and it is difficult to promptly feedback the specific problems; Debugging methods based on logs and monitoring: Locate and analyze problems by recording the log information during system operation and combining monitoring tools. However, this method relies on runtime data and it is difficult to discover potential problems in a timely manner. Summary of the Invention

[0004] In view of this, the present invention provides a system, method, storage medium and program product for testing an entity component system to solve the problems of low efficiency of traditional system testing methods, long time consumption and difficulty in promptly feedbacking specific problems when dealing with complex interactions and large-scale data.

[0005] In a first aspect, the present invention provides a system for testing an entity component system. The system includes a configuration manager, a test center, and test executors. Among them, the configuration manager integrates a system test configuration parameter file, which is used to respond to the target test configuration parameters customized by the user based on the system test configuration parameter file and send them to the test center. The system test configuration parameters characterize various settings and options for controlling the test process. The test center is used to initialize all test executors based on the target test configuration parameters sent by the configuration manager and provide a test execution interface to the user so that the user can select a target test case. The test center integrates the correspondence between each test case and the test executor, and is used to trigger the test operations of the corresponding test executors based on the set of target test cases selected by the user. The set of target test cases includes at least one target test case. The test executor is marked with the corresponding entity component system to be tested, and is used to respond to the test operation triggered by the test center and test the entity component system to be tested based on the target test case.

[0006] For the system for testing an entity component system provided by the present invention, the configuration manager responds to the target test configuration parameters customized by the user and sends them to the test center. The test center initializes all test executors based on the target test configuration parameters and provides a test execution interface to the user so that the user can select a target test case. The test center integrates the correspondence between each test case and the test executor, and is used to trigger the test operations of the corresponding test executors based on the set of target test cases selected by the user. After the test executor responds to the triggered test operation, it can test the entity component system to be tested based on the target test case. By decomposing a complex system into multiple independent test units, the test complexity is greatly reduced, enabling developers to quickly and accurately locate and fix problems in the system, significantly shortening the development and debugging cycle. Through modular design, the test process is made more flexible, and developers can replace or expand modules according to actual needs. Moreover, it is optimized for the ECS architecture and shows higher efficiency and test coverage when dealing with complex interactions, concurrent operations, and large-scale data.

[0007] In an alternative embodiment, the test executor is a specific test executor, which is used to test the entity component system to be tested marked by it based on the corresponding target test case. The system further includes a basic test executor. The basic test executor is used to parse the first test case sent by the test center, determine the first entity component system to be tested corresponding to the first test case, and test the first entity component system to be tested based on the first test case. The first test case matches the target test case set with the corresponding relationship between each test case and the test executor through the test center. If a certain target test case fails to match the test executor, the target test case that fails to match the test executor is determined as the first test case and sent to the basic test executor.

[0008] The present invention designs a basic test executor and a specific test executor to jointly implement the test of the entity component system. Through the test executor, the method of the ECS system instance can be directly called to verify whether its behavior meets the expectation, significantly improving the test efficiency. Especially for large-scale data processing scenarios, the basic test executor can provide general test functions, perform tests on non-specific entity component systems based on non-specific test cases, and improve the comprehensiveness of entity component system tests.

[0009] In an alternative embodiment, the test executor is further used to generate a test result based on the logging setting in the target test configuration parameter, and display the test result to the user through the test execution interface.

[0010] The present invention can record the logs during the test based on the test configuration parameters set by the user and display the logs to the user, enabling the user to clearly understand the system test process. Through the optimization of the test tool chain and process, not only the test quality is improved, but also the cost of system testing and the workload of the user are reduced.

[0011] In an alternative embodiment, the entity component system to be tested is the system module corresponding to the entity component to be tested in the ECS system selected by the user.

[0012] The present invention provides a module for the user to select the system module corresponding to the entity component to be tested, so that the user can select the system to be tested according to different test scenarios, enabling the user to easily customize the test process according to the project requirements.

[0013] Second aspect, the present invention provides a method for testing an entity component system, which is applied to the entity component system testing system of the first aspect or any corresponding implementation manner thereof. The method includes: in response to the target test configuration parameters customized by the user based on the system test configuration parameter file, initializing all test executors based on the target test configuration parameters, where the system test configuration parameters represent various settings and options for controlling the test process; providing a test execution interface to the user to enable the user to select a target test case; triggering the test operations of the corresponding test executors based on the set of target test cases selected by the user, so that the test executors test the entity component system to be tested based on the target test cases, and the set of target test cases includes at least one target test case, where each test case has a corresponding relationship with a test executor, and the test executor is marked with the entity component system to be tested corresponding to it.

[0014] The method for testing an entity component system provided by the present invention, in response to the target test configuration parameters customized by the user based on the system test configuration parameter file, initializes all test executors based on the target test configuration parameters, provides a test execution interface to the user to enable the user to select a target test case; triggers the test operations of the corresponding test executors based on the set of target test cases selected by the user, so that the test executors test the entity component system to be tested based on the target test cases. Under the ECS architecture, it can accurately verify specific system behaviors, realize automated management of the test process, simplify the test execution process, reduce human intervention, and further improve the reliability of the test.

[0015] In an optional implementation manner, the target test configuration parameters at least include test process resources, test basic configuration information, and the test order of each entity component system to be tested. Initializing all test executors based on the target test configuration parameters includes: initializing all test executors based on the test basic configuration information, and releasing the test process resources to the test executors, where the test process resources at least include the resource content for initialization before test execution, test execution, and cleaning after test completion; marking the test order of each entity component system to be tested to the corresponding test executors.

[0016] In an alternative embodiment, the test executor is a specific test executor, which is used to test the to-be-tested entity component system marked thereby based on the corresponding target test cases. Before the test executor tests the to-be-tested entity component system based on the target test cases, the method further includes: obtaining the system identifier of the to-be-tested entity component system, comparing the obtained system identifier with the system identifier of the to-be-tested entity component system marked by itself, and determining whether the to-be-tested entity component system is successfully associated; if the to-be-tested entity component system is successfully associated, checking whether the corresponding test cases and the to-be-tested entity component system meet the security test conditions; if the test security conditions of the corresponding test cases and the to-be-tested entity component system meet the security test conditions, then execute the step of testing the to-be-tested entity component system based on the target test cases in the target test case set.

[0017] Before testing, the specific test executor of the present invention can also pre-determine whether the system identifier of the to-be-tested entity component system is consistent with the system identifier marked by itself, and check whether the test conditions are met. Only after both are determined to be correct, the system test is executed to ensure the security and reliability of the system test.

[0018] In an alternative embodiment, the entity component system test system further includes a basic test executor. The test executor tests the first to-be-tested entity component system based on the first test case in the target test case set, including: parsing and deserializing the first test case to determine the first to-be-tested entity component system corresponding to the first test case. The first test case matches the corresponding relationship between the target test case set and each test case and the test executor through the test center in the entity component system. If a certain target test case fails to match the test executor, the target test case that fails to match the test executor is determined as the first test case; testing the first to-be-tested entity component system based on the first test case.

[0019] If the test center of the present invention determines that a certain test case fails to match the corresponding test executor, it can execute the test based on the unmatched test case through the basic test executor to ensure the integrity and comprehensiveness of the system test.

[0020] In a third aspect, the present invention provides a computer-readable storage medium, on which computer instructions are stored. The computer instructions are used to cause a computer to execute the entity component system test method according to the second aspect or any corresponding embodiment thereof.

[0021] In a fourth aspect, the present invention provides a computer program product, including computer instructions, which are used to cause a computer to execute the entity component system test system according to the first aspect or any corresponding embodiment thereof. Brief Description of the Drawings

[0022] In order to more clearly illustrate the specific embodiments of the present invention or the technical solutions in the prior art, the following will briefly introduce the drawings required for use in the description of the specific embodiments or the prior art. Obviously, the drawings in the following description are some embodiments of the present invention. For those of ordinary skill in the art, without creative efforts, other drawings can also be obtained based on these drawings.

[0023] Figure 1 is a schematic structural diagram of a physical component system test system according to an embodiment of the present invention;

[0024] Figure 2 is an exemplary structural diagram of a physical component system test system according to an embodiment of the present invention;

[0025] Figure 3 is a schematic flowchart of a physical component system test method according to an embodiment of the present invention;

[0026] Figure 4 is an exemplary diagram of port interactions in a physical component system test system according to an embodiment of the present invention;

[0027] Figure 5 is an exemplary flowchart of a physical component system test method according to an embodiment of the present invention;

[0028] Figure 6 is a schematic hardware structure diagram of a computer device according to an embodiment of the present invention. Detailed Embodiments

[0029] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the following will clearly and completely describe the technical solutions in the embodiments of the present invention with reference to the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments are some, but not all, of the embodiments of the present invention. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative efforts fall within the scope of protection of the present invention.

[0030] As the complexity of software systems increases, traditional testing methods have become difficult to meet the requirements of complex interactions and large-scale data processing. The Entity-Component-System (ECS) architecture, as an efficient data processing design model, is widely used in software development. Among them, entities are the basic objects in software, components are data containers attached to entities, and systems process this component data to achieve specific behaviors. By separating objects (entities), data (components), and logic (systems), the ECS architecture significantly improves the performance and flexibility of the system, making large-scale data management and behavior processing possible, but this also poses higher requirements for testing.

[0031] The existing testing methods have the following problems in practice: Low efficiency of manual testing: Manually writing and executing test cases is time-consuming and laborious, and it is difficult to comprehensively cover all scenarios; Insufficient unit test coverage: Traditional unit test frameworks are difficult to fully simulate high concurrency and multi-component interactions in the ECS architecture, resulting in low test coverage; High cost of integration testing: Integration testing and end-to-end testing need to simulate the complete system process, with a long test cycle and unable to provide timely feedback and locate specific problems; Log debugging depends on the runtime environment: Debugging methods based on logs and monitoring rely on runtime data, unable to detect problems in advance during the development stage, and analyzing complex log information requires professional skills; Lack of a unified test tool chain: Existing test tools are scattered, lacking a unified test framework and standards, resulting in a complex test process and high maintenance costs.

[0032] In this embodiment, an entity component system testing system is provided, as Figure 1 shown. The system includes a configuration manager, a test center, and test executors. Among them, the configuration manager integrates a system test configuration parameter file, which is used to respond to the target test configuration parameters customized by the user based on the system test configuration parameter file and send them to the test center. The system test configuration parameters represent various settings and options for controlling the test process; The test center is used to initialize all test executors based on the target test configuration parameters sent by the configuration manager and provide a test execution interface for the user to select target test cases; The test center integrates the correspondence between each test case and the test executor, and is used to trigger the test operations of the corresponding test executors based on the set of target test cases selected by the user. The set of target test cases includes at least one target test case; The test executor is marked with its corresponding entity component system under test, and is used to respond to the test operations triggered by the test center and test the entity component system under test based on the target test case.

[0033] The test framework of the embodiment of the present invention includes a configuration manager, a test center, a test executor, and auxiliary tools such as a test case data parsing tool and a test method marker. Each module can communicate with each other through interfaces to ensure the efficiency and flexibility of the system during the test process.

[0034] As Figure 2 shown, the configuration manager of the embodiment of the present invention is the control center of the entire test process. It integrates a system test configuration parameter file and is responsible for loading and managing the test configuration parameter file. Among them, the test configuration parameters represent various settings and options for controlling the test process, including but not limited to whether to enable specific test functions, whether to record test logs, the root directory of the test file, the definition of the test detail level (whether to enable certain test cases), the test result output format, and the specific components to be tested in the ECS system (the system modules corresponding to the specific components). It allows users to customize test configuration parameters such as global test options, path information, and test processes according to specific needs, ensuring that the tests in different environments can be adaptive, enabling developers to easily customize the test process according to project requirements, saving time and resources. In the system architecture, the configuration manager ensures the flexibility of the test execution process by providing a set of dynamic configuration mechanisms. Users can adjust the test configuration parameters according to the actual situation to meet various test requirements. After the configuration manager responds to the user-defined target test configuration parameters, it can send the target test configuration parameters to the test center.

[0035] The test center of the embodiment of the present invention is the coordination module of the entire test framework. It is responsible for initializing the test environment, scheduling and managing the test executor, and ensuring that the test process proceeds as expected. It can load all relevant test executors and initialize them according to the target test configuration parameters sent by the configuration manager. Among them, as Figure 2As shown, the initialization operation may include using a test marking method to mark the test case file path and output log file path of the test executor. According to the execution order of the test executor in the target test configuration parameters, the corresponding test executor is marked so that the test executor executes test tasks in a predetermined order. The execution order may include the execution sequence of each test executor and may also include the method sequence of a certain test executor for testing, just for example; the initialization operation also includes resource management, initializing and releasing necessary resources during the test process, determining the stability and consistency of the test environment. The test center will record all the resource contents marked with the initialization, test execution, and cleaning methods after the test is completed, and may save the resource methods of initialization, test execution, and cleaning to a hash table. Among them, the initialization mark, test mark, and cleaning mark may respectively include but are not limited to test timing, type, elapsed days, and date, just for example. During the entire test process, the test center ensures the coordination of each test module, ensures the rational use of resources and avoids conflicts, which not only simplifies the work process of developers but also ensures the systematicness and integrity of the test; after initialization is completed, the test center can display the test execution interface to the user through the test executor window. The user can select specific test cases in the interface and trigger the test operation. The test center integrates the one-to-one correspondence between each test case and the test executor. In response to the target test case set selected by the user, it can trigger the test operation of the corresponding test executor.

[0036] The test executor is the core module for executing tests. As Figure 2 shown, the test executor mark with the entity system is used to configure the applicable scope and target entity component system of the test executor. It is specifically used to handle specific test requirements in the ECS system. It can verify whether the behavior of the entity component system is accurate by directly calling the system instance method. At the same time, it implements the test executor interface so that it can be uniformly scheduled. The test executor responds to the test operation triggered by the test center and can test the entity component system to be tested based on its corresponding target test case. By applying the marking method to the test executor, it can ensure that the test process is automatically adjusted according to different system requirements, making the test process more flexible and adaptable.

[0037] Specifically, the entity component system to be tested is the system module corresponding to the entity component to be tested in the ECS system selected by the user.

[0038] The user of the embodiment of the present invention can select the system module corresponding to the entity component to be tested through the configuration manager. In the subsequent selection of test cases, the user can select the target test case corresponding to the entity component system to be tested previously selected to test the selected entity component system to be tested.

[0039] The present invention provides a module for a user to select a system module corresponding to an entity component to be tested, so that the user can select a system to be tested according to different test scenarios, enabling the user to easily customize the test process according to project requirements.

[0040] The entity component system testing system provided by the present invention, the configuration manager responds to user-defined target test configuration parameters and sends them to the test center. The test center initializes all test executors based on the target test configuration parameters and provides a test execution interface to the user to enable the user to select a target test case. The test center integrates the corresponding relationship between each test case and the test executor, and is used to trigger the test operation of the corresponding test executor based on the set of target test cases selected by the user. After the test executor responds to the triggered test operation, it can test the entity component system to be tested based on the target test case. By decomposing a complex system into multiple independent test units, the test complexity is greatly reduced, enabling developers to quickly and accurately locate and fix problems in the system, significantly shortening the development and debugging cycle. Through modular design, the test process is made more flexible, and developers can replace or expand modules according to actual needs. Moreover, it is optimized for the ECS architecture and shows higher efficiency and test coverage when dealing with complex interactions, concurrent operations, and large-scale data.

[0041] In an alternative embodiment, the above test executor is a specific test executor for testing the entity component system to be tested marked by it based on the corresponding target test case. The entity component system testing system further includes a basic test executor, where the basic test executor is used to parse the first test case sent by the test center, determine the first entity component system to be tested corresponding to the first test case, and test the first entity component system to be tested based on the first test case.

[0042] Among them, for the first test case, the test center matches the set of target test cases with the corresponding relationship between each test case and the test executor. If a certain target test case fails to match the test executor, the target test case that fails to match the test executor is determined as the first test case and sent to the basic test executor.

[0043] The specific test executor (specific system test executor or the test executor with the physical system mentioned above) in the embodiment of the present invention extends or inherits from the basic test executor and is specifically used to handle the specific test requirements in the ECS system. That is, each specific test executor is marked with its corresponding entity component system to be tested. It can directly call the test case method of the corresponding entity component system to be tested to verify whether the behavior of the system is accurate. Under the ECS architecture, it can accurately verify specific system behaviors, simplify the test execution process, reduce human intervention, and further improve the reliability of the test. The basic test executor provides general test functions. It can share some test cases and generate a detailed test report after the test. The test center matches the set of target test cases selected by the user with the corresponding relationship between each test case and the test executor. If a target test case fails to match a test executor, it means that it is not a specific test requirement of a certain system. Then, the unmatched target test case can be sent to the basic test executor. The basic test executor can use the test case data parsing tool to parse the target test case, deserialize it to determine the entity component system to be tested applied by the target test case. After the determination is completed, the basic test executor can test the corresponding determined entity component system based on the target test case to obtain the test result.

[0044] The present invention designs the basic test executor and the specific test executor to jointly implement the test of the entity component system. Through the test executor, the method of the ECS system instance can be directly called to verify whether its behavior meets the expectation, significantly improving the test efficiency. Especially for large-scale data processing scenarios, the basic test executor can provide general test functions, perform tests on non-specific entity component systems based on non-specific test cases, and improve the comprehensiveness of the entity component system test.

[0045] In an optional implementation manner, the test executor is also used to generate a test result based on the logging setting in the target test configuration parameter and display the test result to the user through the test execution interface.

[0046] The test executor in the embodiment of the present invention can also generate a detailed log file based on the setting in the test configuration parameter (that is, whether to record the test log selected by the user in the configuration manager), including the execution situation, results of each test step, and any possible errors, and can display the test result and the log file to the user through the test execution interface of the test executor window.

[0047] The present invention can record the log during the test based on the test configuration parameter set by the user and display the log to the user, enabling the user to clearly understand the process of the system test. Through the optimization of the test tool chain and process, not only the test quality is improved, but also the cost of the system test and the workload of the user are reduced.

[0048] According to an embodiment of the present invention, an embodiment of a method for testing an entity component system is provided. It should be noted that the steps shown in the flowchart of the accompanying drawings can be executed in a computer system such as a set of computer-executable instructions. And although the logical order is shown in the flowchart, in some cases, the steps shown or described can be executed in a different order than here.

[0049] In this embodiment, a method for testing an entity component system is provided, which is applied to the above-mentioned entity component system testing system. Figure 3 It is a flowchart of a method for testing an entity component system according to an embodiment of the present invention, as Figure 3 shown, the process includes the following steps:

[0050] Step S301, in response to the target test configuration parameters customized by the user based on the system test configuration parameter file, initialize all test executors based on the target test configuration parameters.

[0051] Among them, the system test configuration parameters represent various settings and options for controlling the test process.

[0052] As Figure 4 shown, when the user triggers the test of the entity component system, the configuration manager is responsible for loading the test configuration parameter file. Among them, the test configuration parameter file defines global test options, such as whether to enable logging, the storage path of test cases, etc. When the configuration loading is completed, the configuration manager returns the test configuration parameter information to the user. After the configuration file is loaded, the user continues to trigger the initialization operation of the test center. The test center obtains the target test configuration parameters from the configuration manager and loads all test executors based on the target test configuration parameters, scans and initializes all test executors in sequence to ensure that the test executors can work properly in the subsequent process. The specific test executor scans and associates the corresponding entity component system based on the identifier of the specific entity component system marked by itself; through the marking and reflection mechanism, the test executor can identify different functional modules of the system and is ready to call the interfaces of these modules during the actual test process.

[0053] Step S302, provide a test execution interface to the user so that the user can select a target test case.

[0054] After the test executor is associated with the corresponding entity component system, the test execution interface can be displayed to the user through the test executor window. The user can select the target test case in the test execution interface and trigger the test operation.

[0055] Step S303: Based on the set of target test cases selected by the user, trigger the test operation of the corresponding test executor, so that the test executor tests the entity component system to be tested based on the target test cases.

[0056] Among them, the set of target test cases includes at least one target test case. Each test case has a corresponding relationship with the test executor, and the test executor is marked with the corresponding entity component system to be tested.

[0057] The test center in the embodiment of the present invention can match the set of target test cases selected by the user with the corresponding relationship between each test case and the test executor based on the corresponding relationship between each test case and the test executor integrated in itself, determine the corresponding relationship between the target test case and the test executor, and trigger the test executor to execute the test operation. The test executor tests the corresponding marked entity component system to be tested based on the target test case. If the test center determines that a certain target test case fails to match any test executor successfully, it sends the target test case to the basic test executor. The basic test executor obtains and parses the target test case, and can deserialize through the test case output parsing tool to obtain a specific test case object (that is, the entity component system to be tested), and then can test the determined test case object based on the target test case.

[0058] The entity component system testing method provided in this embodiment responds to the target test configuration parameters customized by the user based on the system test configuration parameter file. Based on the target test configuration parameters, initialize all test executors, and provide a test execution interface for the user to select target test cases; based on the set of target test cases selected by the user, trigger the test operation of the corresponding test executor, so that the test executor tests the entity component system to be tested based on the target test cases. Under the ECS architecture, it can accurately verify specific system behaviors, realize automated management of the test process, simplify the test execution process, reduce human intervention, and further improve the reliability of the test.

[0059] Specifically, initializing all test executors based on the target test configuration parameters includes: initializing all test executors based on the test basic configuration information, and releasing the test process resources to the test executors. The test process resources at least include the resource content of initialization before test execution, test execution, and cleaning after test completion; mark the test order of each entity component system to be tested to the corresponding test executor.

[0060] Among them, the target test configuration parameters at least include test process resources, test basic configuration information, and the test order of each entity component system to be tested.

[0061] The test center in the embodiments of the present invention can use the test marking method to mark the test case file path and output log file path of the test executor, and mark the corresponding test executor according to the execution order of the test executor in the target test configuration parameters, so that the test executor executes the test tasks in a predetermined order. The execution order can include the execution order of each test executor, or the method execution order of a certain test executor for testing, only for example; it can also initialize and release necessary resources during the test process, determine the stability and consistency of the test environment. The test center will record all the resource contents marked with the initialization before the test, test execution, and cleaning methods after the test completion, and can save the resource methods of initialization, test execution, and cleaning into a hash table. Among them, the initialization mark, test mark, and cleaning mark can respectively include but are not limited to the test timing, type, elapsed days, and date, only for example. During the whole test process, the test center ensures the coordination of each test module, ensures the reasonable utilization of resources and avoids conflicts, which not only simplifies the work process of developers, but also ensures the systematicness and integrity of the test.

[0062] In an alternative embodiment, the above-mentioned test executor is a specific test executor, which is used to test the marked entity component system to be tested based on its corresponding target test case. Before the test executor tests the entity component system to be tested based on the target test case, the method further includes: obtaining the system identifier of the entity component system to be tested, comparing the obtained system identifier with the system identifier of the entity component system to be tested marked by itself, and determining whether the entity component system to be tested is successfully associated; if the entity component system to be tested is successfully associated, checking whether the corresponding test case and the entity component system to be tested meet the security test conditions; if the test security conditions of the corresponding test case and the entity component system to be tested meet the security test conditions, then execute the step of testing the entity component system to be tested based on the target test case in the target test case set.

[0063] The above-mentioned test executor is a specific test executor, which corresponds to associated test cases and entity component systems to be tested, and is used to test the marked entity component systems to be tested based on its corresponding target test cases. Specifically, such as Figure 4As shown, before the test, the specific test executor can verify its association with the entity component system to be tested through system tags. For example, it can obtain the system identifier of the entity component system to be tested, compare the obtained system identifier with the entity component system to be tested marked by itself, and determine whether the association with the entity component system to be tested is successful. If the association is successful, it can then detect whether the corresponding test case and the entity component system to be tested meet the security test conditions. For example, it can determine whether the test conditions are met through the code in the specific test executor. If the security test conditions are met, the test on the entity component system to be tested is performed based on the target test case. If the security test conditions are not met, the test operation can be aborted.

[0064] Before the test, the specific test executor of the present invention can also pre-determine whether the system identifier of the entity component system to be tested is consistent with the system identifier marked by itself, and check whether the test conditions are met. Only after both are confirmed to be correct, the system test is performed to ensure the security and reliability of the system test.

[0065] In an alternative embodiment, the entity component system test system further includes a basic test executor. The test executor tests the first entity component system to be tested based on the first test case in the target test case set, including: parsing and deserializing the first test case to determine the first entity component system to be tested corresponding to the first test case. The first test case matches the corresponding relationship between the target test case set, each test case, and the test executor through the test center in the entity component system. If a certain target test case fails to match the test executor, the target test case that fails to match the test executor is determined as the first test case; and testing the first entity component system to be tested based on the first test case.

[0066] If the test center of the embodiment of the present invention determines that a certain target test case fails to match any test executor, it sends the target test case to the basic test executor. The basic test executor obtains and parses the target test case, and can deserialize it through the test case output parsing tool to obtain a specific test case object (i.e., the entity component system to be tested), and then can test the determined test case object based on the target test case.

[0067] If the test center of the present invention determines that a certain test case fails to match the corresponding test executor, it can perform the test based on the unmatched test case through the basic test executor to ensure the integrity and comprehensiveness of the system test.

[0068] In a specific embodiment, such as Figure 5As shown, before designing the test framework for entity component systems, the content of test cases can be pre-written, the file format of test cases can be defined, the parsing of test case files can be implemented, and the test code logic can output test logs. After that, tests can be performed based on the entity component system test system. The configuration manager provides an interface for users to customize target test configuration parameters. The test center initializes the test environment, schedules, and manages test executors based on the target test configuration parameters to ensure the efficient execution of the test process. The basic tester obtains and parses test cases, deserializes to determine the corresponding entity component system to be tested, and executes the test. The specific test executor performs tests on the marked entity component system to be tested based on its corresponding target test case, verifies the behavior of the entity component system to be tested, records the log file, and displays it to the user. For detailed descriptions, please refer to the above embodiments and will not be elaborated here.

[0069] Please refer to Figure 6 , Figure 6 FIG. is a schematic structural diagram of a computer device provided by an optional embodiment of the present invention. As Figure 6 shown, the computer device includes: one or more processors 10, a memory 20, and interfaces for connecting various components, including a high-speed interface and a low-speed interface. Each component communicates with each other using different buses and can be installed on a common motherboard or installed in other ways as needed. The processor can process instructions executed within the computer device, including instructions stored in the memory or on the memory to display graphical information of the GUI on an external input / output device (such as a display device coupled to the interface). In some optional embodiments, if necessary, multiple processors and / or multiple buses can be used together with multiple memories and multiple memories. Similarly, multiple computer devices can be connected, and each device provides some necessary operations (such as a server array, a set of blade servers, or a multi-processor system). Figure 6 In FIG., one processor 10 is taken as an example.

[0070] The processor 10 can be a central processing unit, a network processor, or a combination thereof. Among them, the processor 10 can further include a hardware chip. The above hardware chip can be an application-specific integrated circuit, a programmable logic device, or a combination thereof. The above programmable logic device can be a complex programmable logic device, a field programmable gate array, a general array logic, or any combination thereof.

[0071] Among them, the memory 20 stores instructions executable by at least one processor 10, so that at least one processor 10 executes the method shown in the above embodiments.

[0072] The memory 20 may include a program storage area and a data storage area. The program storage area may store an operating system and application programs required for at least one function. The data storage area may store data created according to the use of the computer device and the like. In addition, the memory 20 may include a high-speed random access memory and may also include a non-transitory memory, such as at least one magnetic disk storage device, a flash memory device, or other non-transitory solid-state storage devices. In some alternative embodiments, the memory 20 may optionally include a memory remotely provided with respect to the processor 10, and these remote memories may be connected to the computer device through a network. Examples of the above-mentioned network include, but are not limited to, the Internet, an intranet, a local area network, a mobile communication network, and combinations thereof.

[0073] The memory 20 may include a volatile memory, such as a random access memory. The memory may also include a non-volatile memory, such as a flash memory, a hard disk, or a solid-state drive. The memory 20 may also include a combination of the above types of memories.

[0074] The computer device further includes an input device 30 and an output device 40. The processor 10, the memory 20, the input device 30, and the output device 40 may be connected through a bus or other means. Figure 6 Taking connection through a bus as an example.

[0075] The input device 30 may receive input digital or character information and generate key signal inputs related to the user settings and function controls of the computer device, such as a touch screen, a keypad, a mouse, a trackpad, a touchpad, a pointing stick, one or more mouse buttons, a trackball, a joystick, etc. The output device 40 may include a display device, an auxiliary lighting device (e.g., an LED), and a haptic feedback device (e.g., a vibration motor), etc. The above-mentioned display device includes, but is not limited to, a liquid crystal display, a light-emitting diode, a display, and a plasma display. In some alternative embodiments, the display device may be a touch screen.

[0076] Embodiments of the present invention also provide a computer-readable storage medium. The method according to the embodiments of the present invention can be implemented in hardware, firmware, or be implemented as computer code that can be recorded on a storage medium, or be implemented as computer code that is originally stored in a remote storage medium or a non-transitory machine-readable storage medium and downloaded through a network and will be stored in a local storage medium, so that the method described herein can be stored as such software processing on a storage medium using a general-purpose computer, a dedicated processor, or programmable or dedicated hardware. Among them, the storage medium can be a magnetic disk, an optical disk, a read-only memory, a random access memory, a flash memory, a hard disk, or a solid-state drive, etc.; further, the storage medium can also include a combination of the above-mentioned types of memories. It can be understood that a computer, a processor, a microprocessor controller, or programmable hardware includes a storage component that can store or receive software or computer code, and when the software or computer code is accessed and executed by the computer, the processor, or the hardware, the method shown in the above embodiments is implemented.

[0077] A part of the present invention can be applied as a computer program product, for example, computer program instructions, when executed by a computer, can call or provide the method and / or technical solution according to the present invention through the operation of the computer. Those skilled in the art should be able to understand that the forms in which computer program instructions exist in a computer-readable medium include, but are not limited to, source files, executable files, installation package files, etc. Correspondingly, the ways in which computer program instructions are executed by a computer include, but are not limited to: the computer directly executes the instruction, or the computer compiles the instruction and then executes the corresponding compiled program, or the computer reads and executes the instruction, or the computer reads and installs the instruction and then executes the corresponding installed program. Herein, the computer-readable medium can be any available computer-readable storage medium or communication medium accessible to the computer.

[0078] Although the embodiments of the present invention have been described in conjunction with the accompanying drawings, those skilled in the art can make various modifications and variations without departing from the spirit and scope of the present invention, and such modifications and variations all fall within the scope defined by the appended claims.

Claims

1. A physical component system testing system, characterized in that: The system includes a configuration manager, a test center and a test executor, wherein: The configuration manager is integrated with a system test configuration parameter file, which is used to respond to the target test configuration parameters customized by the user based on the system test configuration parameter file and send them to the test center, wherein the system test configuration parameters represent various settings and options for controlling the test process; The test center is used to initialize all test executors based on the target test configuration parameters sent by the configuration manager, and provide a test execution interface to the user so that the user can select the target test case; The test center integrates the correspondence between each test case and the test executor, and is used to trigger the test operation of the corresponding test executor based on the target test case set selected by the user, wherein the target test case set includes at least one target test case; The test executor is marked with its corresponding entity component system to be tested, and is used to respond to the test operation triggered by the test center and test the entity component system to be tested based on the target test case; the test executor is a specific test executor, which is used to test the entity component system to be tested marked by it based on its corresponding target test case; The system also includes a basic test executor, wherein the basic test executor is used to parse a first test case sent by a test center, determine a first entity component system to be tested corresponding to the first test case, and test the first entity component system to be tested based on the first test case. The first test case matches a target test case set with the correspondence between each test case and the test executor through the test center. If a target test case fails to match the test executor successfully, the target test case that fails to match the test executor is determined as the first test case and sent to the basic test executor.

2. The system according to claim 1, characterized in that The test executor is also used to generate test results based on the logging settings in the target test configuration parameters, and present the test results to the user through the test execution interface.

3. The system according to claim 1, characterized in that The entity component system to be tested is a system module corresponding to the entity component to be tested in the ECS system selected by the user.

4. A method for testing an entity component system, characterized in that: The method is applied to the entity component system testing system according to any one of claims 1 to 3, and the method comprises: In response to a target test configuration parameter customized by a user based on a system test configuration parameter file, initializing all test executors based on the target test configuration parameter, the system test configuration parameter representing various settings and options for controlling a test flow; Provide a test execution interface to the user so that the user can select a target test case; Based on the target test case set selected by the user, the test operation of the corresponding test executor is triggered, so that the test executor tests the entity component system to be tested based on the target test case, wherein the target test case set includes at least one target test case, wherein each test case has a corresponding relationship with the test executor, and the test executor is marked with its corresponding entity component system to be tested. The test executor is a specific test executor, which is used to test the marked entity component system to be tested based on its corresponding target test case; The entity component system testing system further includes a basic test executor, which tests the first entity component system to be tested based on a first test case in a target test case set, including: The first test case is parsed and deserialized to determine the first entity component system to be tested corresponding to the first test case. The first test case matches the target test case set with the correspondence between the test cases and the test executor through the test center in the entity component system. If a target test case fails to match the test executor successfully, the target test case that fails to match the test executor is determined as the first test case. The first entity component system to be tested is tested based on the first test case.

5. The method according to claim 4, characterized in that The target test configuration parameters at least include test process resources, test basic configuration information and the test sequence of each entity component system to be tested. Initializing all test executors based on the target test configuration parameters includes: Initialize all test executors based on the test basic configuration information, and release the test process resources to the test executors, wherein the test process resources at least include resource contents of initialization before test execution, test execution, and cleanup after test completion; The test sequences of the entity component systems to be tested are marked in the corresponding test executors.

6. The method according to claim 4, characterized in that The test executor is a specific test executor, which is used to test the entity component system to be tested marked by it based on the target test case corresponding to itself. Before the test executor tests the entity component system to be tested based on the target test case, the method also includes: Obtaining the system identifier of the entity component system to be tested, comparing the obtained system identifier with the system identifier of the entity component to be tested marked by itself, and determining whether the entity component system to be tested is successfully associated; If the entity component system to be tested is successfully associated, check whether the corresponding test cases and the entity component system to be tested meet the safety test conditions; If the corresponding test case and the test safety conditions of the entity component system to be tested meet the safety test conditions, the step of testing the entity component system to be tested based on the target test case in the target test case set is executed.

7. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores computer instructions, and the computer instructions are used to enable a computer to execute the entity component system testing method according to any one of claims 4 to 6.

8. A computer program product, characterized in that The method comprises computer instructions, wherein the computer instructions are used to cause a computer to execute the entity component system testing method according to any one of claims 4 to 6.

Images