CN117743130A - Test method, device, test system and network equipment - Google Patents
Test method, device, test system and network equipment Download PDFInfo
- Publication number
- CN117743130A CN117743130A CN202211113631.5A CN202211113631A CN117743130A CN 117743130 A CN117743130 A CN 117743130A CN 202211113631 A CN202211113631 A CN 202211113631A CN 117743130 A CN117743130 A CN 117743130A
- Authority
- CN
- China
- Prior art keywords
- test
- target
- framework
- calling
- embedded
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000012360 testing method Methods 0.000 title claims abstract description 371
- 238000010998 test method Methods 0.000 title claims description 15
- XSQUKJJJFZCRTK-NJFSPNSNSA-N UREA C 14 Chemical compound N[14C](N)=O XSQUKJJJFZCRTK-NJFSPNSNSA-N 0.000 claims abstract description 46
- 238000000034 method Methods 0.000 claims abstract description 28
- 230000006870 function Effects 0.000 claims description 70
- 238000013522 software testing Methods 0.000 abstract description 2
- 238000004458 analytical method Methods 0.000 description 10
- 230000008569 process Effects 0.000 description 9
- 238000005516 engineering process Methods 0.000 description 6
- 230000010354 integration Effects 0.000 description 6
- 238000010586 diagram Methods 0.000 description 4
- 230000009286 beneficial effect Effects 0.000 description 3
- 230000000694 effects Effects 0.000 description 3
- 238000012545 processing Methods 0.000 description 3
- 230000006978 adaptation Effects 0.000 description 2
- 238000003491 array Methods 0.000 description 2
- 230000000977 initiatory effect Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 238000004088 simulation Methods 0.000 description 2
- 230000005540 biological transmission Effects 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 238000013461 design Methods 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 239000002360 explosive Substances 0.000 description 1
- 230000003993 interaction Effects 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 230000007246 mechanism Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000002093 peripheral effect Effects 0.000 description 1
- 239000004065 semiconductor Substances 0.000 description 1
- 238000012795 verification Methods 0.000 description 1
Abstract
The invention provides a testing method, a testing device, a testing system and network equipment, and relates to the technical field of embedded software testing. The method comprises the following steps: obtaining target information of a test object, wherein the test object comprises: embedded software and/or application software; according to the target information, calling a Pytest test framework to test the test object to obtain a test result; and calling an alure test report framework, and generating an alure report according to the test result. The scheme of the invention solves the problem that an automatic test scheme aiming at multiple test scenes and multiple test objects is lacking in the prior art.
Description
Technical Field
The present invention relates to the field of embedded software testing technologies, and in particular, to a testing method, a testing device, a testing system, and a network device.
Background
Common automation test scenarios are unit tests or integrated tests, and the type of the object to be tested is often application software (single application software or multi-application software) or embedded software, so that the technology selection is usually performed for one of the application software or the embedded software.
With the continuous development of the internet of things technology, the number of embedded devices accessing the internet is increased in a explosive manner, and the scenes of the interaction of the embedded devices and the application software are more and more complex, and mainly comprise the following scenes: over-the-Air Technology (OTA) upgrades, device cloud, device interactions with application software. The current integrated test automatic execution system is only aimed at embedded software, but the simulation environment is difficult to cover a cloud, an upgrading platform or other application platforms, so that the current automatic integrated test technology cannot test the verification of integrated scenes such as end-to-end cloud combination, OTA upgrading and the like. In summary, the prior art lacks an automatic test scheme for multiple test scenes and multiple test objects, and has low test efficiency.
Disclosure of Invention
The invention aims to provide a testing method, a testing device, a testing system and network equipment, which solve the problem that an automatic testing scheme aiming at multiple testing scenes and multiple testing objects is lacked in the prior art.
To achieve the above object, an embodiment of the present invention provides a testing method, including:
obtaining target information of a test object, wherein the test object comprises: embedded software and/or application software;
according to the target information, calling a Pytest test framework to test the test object to obtain a test result;
and calling an alure test report framework, and generating an alure report according to the test result.
Optionally, the target information includes at least one of:
jenkins support code;
the code to be tested of the embedded software;
a test set, the test set comprising: the test cases and the common functions are integrated.
Optionally, the step of calling a Pytest test framework to test the test object according to the target information to obtain a test result includes:
setting a case check point for the integrated test case;
and calling the Pytest test framework, and testing the test object by using the test set to obtain a test result corresponding to the use case check point.
Optionally, in the case that the test object is embedded software, before the calling the Pytest test framework and using the test set to test the test object, the method further includes:
compiling the tested code of the embedded software to generate a binary file;
and burning the binary file into target embedded equipment, and taking the target embedded equipment as a test object.
Optionally, the burning the binary file into the target embedded device includes:
acquiring a target port of the target embedded equipment according to a first label preconfigured for the target embedded equipment in the Pytest test framework;
and connecting the target port, and burning the binary file into target embedded equipment through the target port.
Optionally, the public function includes at least one of:
support interface functions of embedded software;
calling a function by an interface of the embedded software;
the result of the embedded software analyzes the function;
calling a function by an interface of the application software;
the result of the application software parses the function.
To achieve the above object, an embodiment of the present invention provides a test apparatus, including:
the acquisition module is used for acquiring target information of a test object, wherein the test object comprises: embedded software and/or application software;
the test module is used for calling a Pytest test frame to test the test object according to the target information to obtain a test result;
and the report module is used for calling an alure test report framework and generating an alure report according to the test result.
Optionally, the target information includes at least one of:
jenkins support code;
the code to be tested of the embedded software;
a test set, the test set comprising: the test cases and the common functions are integrated.
Optionally, the test module includes:
the checking setting sub-module is used for setting a case check point for the integrated test case;
and the first processing sub-module is used for calling the Pytest test framework, testing the test object by utilizing the test set, and obtaining a test result corresponding to the use case check point.
Optionally, the apparatus further comprises:
the compiling sub-module is used for compiling the tested code of the embedded software to generate a binary file;
and the burning sub-module is used for burning the binary file into target embedded equipment and taking the target embedded equipment as a test object.
Optionally, the burning submodule includes:
the acquisition unit is used for acquiring a target port of the target embedded equipment according to a first label preconfigured for the target embedded equipment in the Pytest test framework;
and the burning unit is used for connecting the target port and burning the binary file into the target embedded equipment through the target port.
Optionally, the public function includes at least one of:
support interface functions of embedded software;
calling a function by an interface of the embedded software;
the result of the embedded software analyzes the function;
calling a function by an interface of the application software;
the result of the application software parses the function.
To achieve the above object, an embodiment of the present invention provides a test system, including the test device as described above, further including:
the Pytest test framework is used for testing the test object to obtain a test result;
and the alure test report framework is used for generating an alure report according to the test result.
To achieve the above object, an embodiment of the present invention provides a network device, including a processor and a transceiver, where the processor is configured to:
obtaining target information of a test object, wherein the test object comprises: embedded software and/or application software;
according to the target information, calling a Pytest test framework to test the test object to obtain a test result;
and calling an alure test report framework, and generating an alure report according to the test result.
Optionally, the target information includes at least one of:
jenkins support code;
the code to be tested of the embedded software;
a test set, the test set comprising: the test cases and the common functions are integrated.
Optionally, when the processor calls the Pytest test framework to test the test object according to the target information to obtain a test result, the processor is specifically configured to:
setting a case check point for the integrated test case;
and calling the Pytest test framework, and testing the test object by using the test set to obtain a test result corresponding to the use case check point.
Optionally, the processor is further configured to:
compiling the tested code of the embedded software to generate a binary file;
and burning the binary file into target embedded equipment, and taking the target embedded equipment as a test object.
Optionally, the processor is specifically configured to, when burning the binary file into the target embedded device:
acquiring a target port of the target embedded equipment according to a first label preconfigured for the target embedded equipment in the Pytest test framework;
and connecting the target port, and burning the binary file into target embedded equipment through the target port.
Optionally, the public function includes at least one of:
support interface functions of embedded software;
calling a function by an interface of the embedded software;
the result of the embedded software analyzes the function;
calling a function by an interface of the application software;
the result of the application software parses the function.
To achieve the above object, an embodiment of the present invention provides a network device including a transceiver, a processor, a memory, and a program or instructions stored on the memory and executable on the processor; the processor, when executing the program or instructions, implements the test method as described above.
To achieve the above object, an embodiment of the present invention provides a readable storage medium having stored thereon a program or instructions which, when executed by a processor, implement steps in a test method as described above, or steps in a test method as described above.
The technical scheme of the invention has the following beneficial effects:
according to the method provided by the embodiment of the invention, after the target information of the test object is obtained, the Pytest test framework is called, so that the automatic test of different test objects (such as embedded software and/or application software) can be realized, the test result is obtained, and further, the multi-dimensional and content-rich alure test report can be generated by calling the alure test report framework, so that the method is suitable for different test scenes, and the integrated test efficiency is improved.
Drawings
FIG. 1 is a flow chart of a testing method according to an embodiment of the invention;
FIG. 2 is a block diagram of a test system according to an embodiment of the present invention;
FIG. 3 is a flow chart of a testing method according to another embodiment of the invention;
FIG. 4 is a block diagram of a test apparatus according to an embodiment of the present invention;
fig. 5 is a block diagram of a network device according to an embodiment of the present invention;
fig. 6 is a block diagram of a network device according to another embodiment of the present invention.
Detailed Description
In order to make the technical problems, technical solutions and advantages to be solved more apparent, the following detailed description will be given with reference to the accompanying drawings and specific embodiments.
It should be appreciated that reference throughout this specification to "one embodiment" or "an embodiment" means that a particular feature, structure or characteristic described in connection with the embodiment is included in at least one embodiment of the present invention. Thus, the appearances of the phrases "in one embodiment" or "in an embodiment" in various places throughout this specification are not necessarily all referring to the same embodiment. Furthermore, the particular features, structures, or characteristics may be combined in any suitable manner in one or more embodiments.
In various embodiments of the present invention, it should be understood that the sequence numbers of the following processes do not mean the order of execution, and the order of execution of the processes should be determined by the functions and internal logic, and should not constitute any limitation on the implementation process of the embodiments of the present invention.
In addition, the terms "system" and "network" are often used interchangeably herein.
In the examples provided herein, it should be understood that "B corresponding to a" means that B is associated with a from which B may be determined. It should also be understood that determining B from a does not mean determining B from a alone, but may also determine B from a and/or other information.
As shown in fig. 1, a testing method according to an embodiment of the present invention includes:
step 101, obtaining target information of a test object, wherein the test object comprises: embedded software and/or application software.
In this step, target information of the test object may be acquired so as to test the test object later. Here, the test object may be embedded software or application software, so the test method according to the embodiment of the present invention supports automatic integrated test for the embedded device corresponding to the embedded software and the web platform corresponding to the application software (for example, cloud platform, OTA platform, application platform, etc.).
It should be noted that, the test method of the embodiment of the invention can be realized based on Jenkins service, and the Jenkins service supports continuous software version release/test projects and can monitor the work of external calling execution. Here, the Jenkins service is mainly responsible for task scheduling, executive management, and report collection. Specifically, the Jenkins service is responsible for creating projects, each of which may include a number of tasks, such as: the method comprises the following steps of executing a Checkout task (code downloading task), a compiler task (compiling task), a Flash task (firmware downloading task), a Test task (integrated Test task), a report task (report presentation task), and enabling a Jenkins service to be responsible for scheduling among the tasks, so that automatic pipeline operation of the Test is realized.
The Jenkins service can manage the executor and the measured object information (also can be a simulation system) and is provided with a lock mechanism. Thus, when a certain task is distributed to a certain execution machine to execute the task, the operation of the task can be ensured through the lock, and the rest tasks are distributed to idle execution machines and environments to execute. In this process, if there are more tasks, queuing may be required.
And 102, according to the target information, calling a Pytest test framework to test the test object to obtain a test result.
Here, the Pytest integrated test service (i.e., pytest test framework) may provide a simple integrated test framework, and test the test object, which is easy to implement.
And step 103, calling an alure test report framework, and generating an alure report according to the test result.
Here, an alure service (i.e., an alure test report framework) may be integrated in the Jenkins service, which is capable of multi-dimensional, content-rich test reports. Specifically, the alure test report framework may be responsible for summarizing the execution results of each execution machine, and the alure test report framework not only can provide comprehensive information of integrated test operation, but also can provide and display analysis charts of various dimensions, including: item overview (e.g., execution duration, total number of use cases, number of success cases, number of failure cases, etc.), charts (e.g., test state analysis table, test case class analysis table, test execution time analysis table, etc.), analysis by execution time, analysis by defect type, analysis by test suite, analysis by package module, etc.
In this embodiment, the design of the automation test framework of jenkins+pytest+alure may be adopted, and the automation integrated test may be completed by a task scheduling manner. Specifically, after the target information of the test object is obtained, the Pytest test framework is called, so that automatic test on different test objects (such as embedded software and/or application software) can be realized, a test result is obtained, and then a multi-dimensional and content-rich alure test report can be generated by calling an alure test report framework, so that the method is suitable for different test scenes, and the integration test efficiency is improved.
Optionally, the target information includes at least one of:
jenkins support code;
the code to be tested of the embedded software;
a test set, the test set comprising: the test cases and the common functions are integrated.
It should be noted that, the above-mentioned Checkout task is mainly used for downloading the target information required by the test from the git library, and after the Checkout task is executed, the target information is uniformly downloaded to the execution machine. Here, an executing machine may be understood as a distributed execution environment scheduled and managed by the Jenkins service, where the executing machine is configured to execute tasks allocated by the Jenkins service.
It should also be noted that the ginkins service may configure the git address of the target information to determine which codes in the git library are used by the project.
Optionally, the step of calling a Pytest test framework to test the test object according to the target information to obtain a test result includes:
setting a case check point for the integrated test case;
and calling the Pytest test framework, and testing the test object by using the test set to obtain a test result corresponding to the use case check point.
It should be noted that, the Test task is mainly responsible for executing the integrated Test case, and the Test set is called through the Pytest framework, that is, each Test suite (a group of related tests are generally referred to as a Test suite, and the Test suite is a set of Test cases) and a public function are called, so as to Test the Test object, and a Test result corresponding to the Test case check point is obtained. The common functions may be used by the integrated test cases, for example, the common functions may include the following: acquiring a device function, closing a port function, restarting the device function, sending a command function, and the like.
Optionally, in the case that the test object is embedded software, before the calling the Pytest test framework and using the test set to test the test object, the method further includes:
compiling the tested code of the embedded software to generate a binary file;
and burning the binary file into target embedded equipment, and taking the target embedded equipment as a test object.
It should be noted that the above-mentioned Compile task may be responsible for compiling the tested code of the test object, the compiling environment supports Windows, linux, etc., and the Jenkins service may obtain the compiling parameters (such as the selection of the compiler) according to the configuration of the user. Here, compiling mainly aims at the situation that the test object is embedded software, and after compiling the tested code of the embedded software, a binary file (bin file) is generated. It should be noted that if the test object is application software, the tested code of the application software does not need to be compiled, and the tested code of the application software can be deployed on the web platform before testing.
Optionally, the burning the binary file into the target embedded device includes:
acquiring a target port of the target embedded equipment according to a first label preconfigured for the target embedded equipment in the Pytest test framework;
and connecting the target port, and burning the binary file into target embedded equipment through the target port.
It should be noted that, the Flash task may be responsible for burning the compiled bin file into the target embedded device. Specifically, after the Flash task is started, a required target embedded device can be found according to a device information tag (i.e., a first tag) configured in the engineering, that is, a serial port required for burning firmware (i.e., a target port of the target embedded device), after the serial port is found and connected, if the target embedded device is occupied, waiting is needed; if the target embedded equipment is in an idle state, the target embedded equipment can be directly used, namely, a burning program is started to download firmware, and the execution result is judged by executing the echo display.
The following specifically illustrates a part of public functions in the embodiment of the present invention:
in the first case, the test object is embedded software:
the target embedded device is obtained through a label configured in the Jenkins service. Specific code examples of this process are as follows:
def get_board(label):
.......
return board；
after the use of the target embedded device is completed, the port of the target embedded device needs to be closed. Specific code examples of this process are as follows:
and sending a Command prompt (cmd) to the target embedded device, and if the Command prompt (cmd) returns an expected value (exp) within the timeout time (timeout), the Command prompt (exp) is successful. Specific code examples of this process are as follows:
when the target embedded device needs to be restarted, the target embedded device can be restarted through a product sequence code (SN code) of the target embedded device. Specific code examples of this process are as follows:
def reset_board(board):
.........
stlink.reset(board[‘sn’])
in the second case, the test object is application software:
the invocation of the application program interface (Application Program Interface, API) on the platform side of the application software may be implemented by a request library of python (computer programming language). Specific code examples of this process are as follows:
optionally, the public function includes at least one of:
support interface functions of embedded software;
calling a function by an interface of the embedded software;
the result of the embedded software analyzes the function;
calling a function by an interface of the application software;
the result of the application software parses the function.
It should be noted that the Pytest framework in the embodiment of the present invention includes an integrated test case and a public function. Wherein the public function comprises: support interface functions to embedded software, such as: a serial port query function, a hardware reset function, a firmware programming function and the like; further comprises: the interface calling function of the embedded software and the result analysis function of the embedded software can be used for initiating a test command to the embedded equipment; further comprises: the interface call function of the application software and the result analysis function of the application software can be used for initiating a test command on the platform end of the application software.
In addition, the Allure test report framework can be used for interfacing with the TMS and bug management platform by calling the northbound API interface provided by the test case management platform (Transportation Management System, TMS) and the bug management platform, so that the TMS and bug management platform are integrated, the result corresponding to the test case can be marked to the TMS platform after the test, thereby realizing automatic case marking, and if the test case fails, the bug can be automatically submitted to the bug management system, and the integrated test efficiency is greatly improved.
The application of the embodiments of the present invention will be described below with reference to specific scenarios.
As shown in fig. 3, for the OTA upgrade scenario of the embedded device, a specific test case may be as follows:
s1: acquiring a source version and a target version to be upgraded of embedded software, calling a login request of an OTA platform, and acquiring a token, wherein the code is exemplified as follows: request_login (login_url, username, password); then, an interface for making the differential packet is called to make the upgrade packet, and the code is as follows: request_post (package_url, token, parameters 1). Wherein, parameters1 represents other parameters, and parameters1 may be one parameter or a plurality of parameters.
S2: invoking the OTA platform interface to issue an upgrade package, illustratively the code: request_post (release_url, token, parameters 2), parameters2 may be according to the actual situation;
s3: the interface (i.e., the target port) of the target embedded device is invoked to acquire the target embedded device, illustratively as follows: get_Board (label), return to the board;
here, the required target embedded device may be found according to the device information tag (i.e., the first tag) configured in the engineering, i.e., the target port of the target embedded device is determined.
S4: invoking an interface of the target embedded device to perform firmware downloading operation on the target embedded device, wherein the code is exemplified as follows: send_cmd (board, 'check', timeout=30), where check is a command for the target embedded device to check firmware update and download firmware;
s5: invoking an interface of the target embedded device to restart the target embedded device, wherein the code is as follows: reset _ board, the target embedded device will enter the upgrade mode after a restart;
s6: and calling an interface of the target embedded equipment to report the upgrade log to the OTA platform. Illustratively, the code is: send_cmd (board, 'report', timeout=30), where report reports commands for the target embedded device upgrade log.
It should be noted that, in the above steps, a use case check point may be set through an assertion, so as to check the correctness of each link.
It should be further noted that, in order to implement the test method of the embodiment of the present invention, correct information needs to be marked in each test case by an alure decorator, and a common alure decorator is as follows:
an @ alure.feature ('test OTA upgrade');
an @ alure. Store ('upgrade package production');
an @ alure. Title ('use case title');
level of @ alure.security (alure.security_level.block) - -, use case;
@ alure. Testcase (url= 'xxx', name= 'TMS platform');
an @ alure.issue (url= 'xxx', name= 'bug management platform');
the @ alure.attribute (body, name. Attribute_type)// attached file information;
patent file (source= 'source file', name=display name, attribute_type=file type).
According to the test method, after the target information of the test object is obtained, the Pytest test framework is called, so that automatic tests on different test objects (such as embedded software and/or application software) can be realized, test results are obtained, further, an alure test report framework is called, a multi-dimensional and content-rich alure test report is generated, the method is suitable for different test scenes, and the integration test efficiency is improved.
As shown in fig. 4, a test apparatus according to an embodiment of the present invention includes:
an obtaining module 410, configured to obtain target information of a test object, where the test object includes: embedded software and/or application software;
the test module 420 is configured to call a Pytest test framework to test the test object according to the target information, so as to obtain a test result;
and the report module 430 is used for calling an alure test report framework and generating an alure report according to the test result.
In this embodiment, after the target information of the test object is obtained, by calling the Pytest test framework, an automatic test on different test objects (for example, embedded software and/or application software) can be realized, so as to obtain a test result, and further, by calling the alure test report framework, a multi-dimensional and content-rich alure test report can be generated, which is suitable for different test scenes, and improves the integration test efficiency.
Optionally, the target information includes at least one of:
jenkins support code;
the code to be tested of the embedded software;
a test set, the test set comprising: the test cases and the common functions are integrated.
Optionally, the test module includes:
the checking setting sub-module is used for setting a case check point for the integrated test case;
and the first processing sub-module is used for calling the Pytest test framework, testing the test object by utilizing the test set, and obtaining a test result corresponding to the use case check point.
Optionally, the apparatus further comprises:
the compiling sub-module is used for compiling the tested code of the embedded software to generate a binary file;
and the burning sub-module is used for burning the binary file into target embedded equipment and taking the target embedded equipment as a test object.
Optionally, the burning submodule includes:
the acquisition unit is used for acquiring a target port of the target embedded equipment according to a first label preconfigured for the target embedded equipment in the Pytest test framework;
and the burning unit is used for connecting the target port and burning the binary file into the target embedded equipment through the target port.
Optionally, the public function includes at least one of:
support interface functions of embedded software;
calling a function by an interface of the embedded software;
the result of the embedded software analyzes the function;
calling a function by an interface of the application software;
the result of the application software parses the function.
It should be noted that, the testing device provided in the embodiment of the present invention can implement all the method steps implemented in the embodiment of the testing method, and can achieve the same technical effects, and detailed descriptions of the same parts and beneficial effects as those in the embodiment of the method are omitted herein.
As shown in fig. 2, a test system according to an embodiment of the present invention includes the test apparatus as described above, and further includes:
the Pytest test framework is used for testing the test object to obtain a test result;
and the alure test report framework is used for generating an alure report according to the test result.
According to the test system provided by the embodiment of the invention, the Pytest test framework is called to realize automatic test on different test objects (such as embedded software and/or application software) to obtain a test result, and then the alure test report framework is called to generate a multi-dimensional and content-rich alure test report, so that the test system is suitable for different test scenes and improves the integration test efficiency.
As shown in fig. 5, a network device 500 according to an embodiment of the present invention includes a processor 510 and a transceiver 520, where the processor is configured to:
obtaining target information of a test object, wherein the test object comprises: embedded software and/or application software;
according to the target information, calling a Pytest test framework to test the test object to obtain a test result;
and calling an alure test report framework, and generating an alure report according to the test result.
In this embodiment, after the target information of the test object is obtained, by calling the Pytest test framework, an automatic test on different test objects (for example, embedded software and/or application software) can be realized, so as to obtain a test result, and further, by calling the alure test report framework, a multi-dimensional and content-rich alure test report can be generated, which is suitable for different test scenes, and improves the integration test efficiency.
Optionally, the target information includes at least one of:
jenkins support code;
the code to be tested of the embedded software;
a test set, the test set comprising: the test cases and the common functions are integrated.
Optionally, when the processor calls the Pytest test framework to test the test object according to the target information to obtain a test result, the processor is specifically configured to:
setting a case check point for the integrated test case;
and calling the Pytest test framework, and testing the test object by using the test set to obtain a test result corresponding to the use case check point.
Optionally, the processor is further configured to:
compiling the tested code of the embedded software to generate a binary file;
and burning the binary file into target embedded equipment, and taking the target embedded equipment as a test object.
Optionally, the processor is specifically configured to, when burning the binary file into the target embedded device:
acquiring a target port of the target embedded equipment according to a first label preconfigured for the target embedded equipment in the Pytest test framework;
and connecting the target port, and burning the binary file into target embedded equipment through the target port.
Optionally, the public function includes at least one of:
support interface functions of embedded software;
calling a function by an interface of the embedded software;
the result of the embedded software analyzes the function;
calling a function by an interface of the application software;
the result of the application software parses the function.
It should be noted that, the network device provided in the embodiment of the present invention can implement all the method steps implemented in the embodiment of the test method and achieve the same technical effects, and the same parts and beneficial effects as those of the embodiment of the method in the embodiment are not described in detail herein.
A network device according to another embodiment of the present invention, as shown in fig. 6, includes a transceiver 610, a processor 600, a memory 620, and a program or instructions stored on the memory 620 and executable on the processor 600; the processor 600 implements the test method described above when executing the program or instructions.
The transceiver 610 is configured to receive and transmit data under the control of the processor 600.
Wherein in fig. 6, a bus architecture may comprise any number of interconnected buses and bridges, and in particular one or more processors represented by processor 600 and various circuits of memory represented by memory 620, linked together. The bus architecture may also link together various other circuits such as peripheral devices, voltage regulators, power management circuits, etc., which are well known in the art and, therefore, will not be described further herein. The bus interface provides an interface. The transceiver 610 may be a number of elements, i.e. comprising a transmitter and a receiver, providing a unit for communicating with various other apparatus over a transmission medium. The processor 600 is responsible for managing the bus architecture and general processing, and the memory 620 may store data used by the processor 600 in performing operations.
The readable storage medium of the embodiment of the present invention stores a program or an instruction, which when executed by a processor, implements the steps in the test method described above, and can achieve the same technical effects, and is not described herein again for avoiding repetition. Wherein the computer readable storage medium is selected from Read-Only Memory (ROM), random access Memory (Random Access Memory, RAM), magnetic disk or optical disk.
It is further noted that the terminals described in this specification include, but are not limited to, smartphones, tablets, etc., and that many of the functional components described are referred to as modules in order to more particularly emphasize their implementation independence.
In an embodiment of the invention, the modules may be implemented in software for execution by various types of processors. An identified module of executable code may, for instance, comprise one or more physical or logical blocks of computer instructions which may, for instance, be organized as an object, procedure, or function. Nevertheless, the executables of an identified module need not be physically located together, but may comprise disparate instructions stored in different bits which, when joined logically together, comprise the module and achieve the stated purpose for the module.
Indeed, a module of executable code may be a single instruction, or many instructions, and may even be distributed over several different code segments, among different programs, and across several memory devices. Likewise, operational data may be identified within modules and may be embodied in any suitable form and organized within any suitable type of data structure. The operational data may be collected as a single data set, or may be distributed over different locations including over different storage devices.
Where a module may be implemented in software, taking into account the level of existing hardware technology, a module may be implemented in software, and one skilled in the art may, without regard to cost, build corresponding hardware circuitry, including conventional Very Large Scale Integration (VLSI) circuits or gate arrays, and existing semiconductors such as logic chips, transistors, or other discrete components, to achieve the corresponding functions. A module may also be implemented in programmable hardware devices such as field programmable gate arrays, programmable array logic, programmable logic devices or the like.
The exemplary embodiments described above are described with reference to the drawings, many different forms and embodiments are possible without departing from the spirit and teachings of the present invention, and therefore, the present invention should not be construed as limited to the exemplary embodiments set forth herein. Rather, these exemplary embodiments are provided so that this disclosure will be thorough and complete, and will convey the scope of the invention to those skilled in the art. In the drawings, the size of the elements and relative sizes may be exaggerated for clarity. The terminology used herein is for the purpose of describing particular example embodiments only and is not intended to be limiting. As used herein, the singular forms "a", "an" and "the" are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will be further understood that the terms "comprises" and/or "comprising," when used in this specification, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof. Unless otherwise indicated, a range of values includes the upper and lower limits of the range and any subranges therebetween.
While the foregoing is directed to the preferred embodiments of the present invention, it will be appreciated by those skilled in the art that various modifications and adaptations can be made without departing from the principles of the present invention, and such modifications and adaptations are intended to be comprehended within the scope of the present invention.
Claims (11)
1. A method of testing, comprising:
obtaining target information of a test object, wherein the test object comprises: embedded software and/or application software;
according to the target information, calling a Pytest test framework to test the test object to obtain a test result;
and calling an alure test report framework, and generating an alure report according to the test result.
2. The method of claim 1, wherein the target information comprises at least one of:
jenkins support code;
the code to be tested of the embedded software;
a test set, the test set comprising: the test cases and the common functions are integrated.
3. The method according to claim 2, wherein the calling the Pytest test framework to test the test object according to the target information to obtain a test result includes:
setting a case check point for the integrated test case;
and calling the Pytest test framework, and testing the test object by using the test set to obtain a test result corresponding to the use case check point.
4. A method according to claim 3, wherein in case the test object is embedded software, before said invoking the Pytest test framework to test the test object with the test set, the method further comprises:
compiling the tested code of the embedded software to generate a binary file;
and burning the binary file into target embedded equipment, and taking the target embedded equipment as a test object.
5. The method of claim 4, wherein the burning the binary file into a target embedded device comprises:
acquiring a target port of the target embedded equipment according to a first label preconfigured for the target embedded equipment in the Pytest test framework;
and connecting the target port, and burning the binary file into target embedded equipment through the target port.
6. The method of claim 2, wherein the common function comprises at least one of:
support interface functions of embedded software;
calling a function by an interface of the embedded software;
the result of the embedded software analyzes the function;
calling a function by an interface of the application software;
the result of the application software parses the function.
7. A test device, comprising:
the acquisition module is used for acquiring target information of a test object, wherein the test object comprises: embedded software and/or application software;
the test module is used for calling a Pytest test frame to test the test object according to the target information to obtain a test result;
and the report module is used for calling an alure test report framework and generating an alure report according to the test result.
8. A test system comprising the test apparatus of claim 7, further comprising:
the Pytest test framework is used for testing the test object to obtain a test result;
and the alure test report framework is used for generating an alure report according to the test result.
9. A network device, comprising: a transceiver and a processor; the processor is configured to:
obtaining target information of a test object, wherein the test object comprises: embedded software and/or application software;
according to the target information, calling a Pytest test framework to test the test object to obtain a test result;
and calling an alure test report framework, and generating an alure report according to the test result.
10. A network device, comprising: a transceiver, a processor, a memory, and a program or instructions stored on the memory and executable on the processor; a test method as claimed in any one of claims 1 to 6 when said program or instructions are executed by said processor.
11. A readable storage medium having stored thereon a program or instructions which when executed by a processor performs the steps in the test method according to any of claims 1 to 6.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211113631.5A CN117743130A (en) | 2022-09-14 | 2022-09-14 | Test method, device, test system and network equipment |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211113631.5A CN117743130A (en) | 2022-09-14 | 2022-09-14 | Test method, device, test system and network equipment |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN117743130A true CN117743130A (en) | 2024-03-22 |
Family
ID=90257811
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202211113631.5A Pending CN117743130A (en) | 2022-09-14 | 2022-09-14 | Test method, device, test system and network equipment |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117743130A (en) |
-
2022
- 2022-09-14 CN CN202211113631.5A patent/CN117743130A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US9940225B2 (en) | Automated error checking system for a software application and method therefor | |
| US7287190B2 (en) | Simultaneous execution of test suites on different platforms | |
| US7099818B1 (en) | System and method for automatically matching components in a debugging system | |
| US20100242031A1 (en) | Systems and Methods for Dynamically Linking Application Software into a Running Operating System Kernel | |
| US20150100832A1 (en) | Method and system for selecting and executing test scripts | |
| US20200183683A1 (en) | Application architecture generation | |
| CN113703730A (en) | Continuous integration method and device, computer equipment and storage medium | |
| US11003668B2 (en) | Programming language independent software testing environment | |
| US20110016454A1 (en) | Method and system for testing an order management system | |
| CN108132876A (en) | A kind of embedded software object code unit test method based on injection mode | |
| CN115904959A (en) | Software integration and deployment method and software development management system | |
| CN113505073A (en) | Database performance test method, device, equipment and medium | |
| EP3447635A1 (en) | Application architecture generation | |
| CN108287720B (en) | Software compiling method, device, equipment and storage medium | |
| CN113254054A (en) | Intelligent contract one-stop development system and method | |
| CN111651169B (en) | Block chain intelligent contract operation method and system based on web container | |
| CN114546819A (en) | Code processing method and device, electronic equipment and readable medium | |
| CN114385258B (en) | Automatic test method, device, electronic equipment and storage medium | |
| CN117743130A (en) | Test method, device, test system and network equipment | |
| CN116126357A (en) | Automatic deployment method and device for test tool, readable storage medium and electronic equipment | |
| CN111581081B (en) | Automatic test system and method | |
| CN113986263A (en) | Code automation test method, device, electronic equipment and storage medium | |
| CN114003257A (en) | Upgrading method and device | |
| US20050034120A1 (en) | Systems and methods for cooperatively building public file packages | |
| CN110928798A (en) | Code testing method, device and equipment |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination |