EMMC test method and device, equipment and storage medium
By integrating a Python interpreter into the u-boot program to parse and execute Python bytecode for eMMC testing, the problem of low test case integration efficiency in existing technologies is solved, and real-time test case execution and efficiency improvement are achieved.
Patent Information
- Application Number
- CN202511236926.5
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2025-09-01
- Publication Date
- 2025-12-30
AI Technical Summary
In existing technologies, eMMC test cases are integrated into the u-boot source code, which requires recompiling and flashing the u-boot image with each update, making it impossible to integrate test cases in real time and resulting in low testing efficiency.
By integrating the Python interpreter into the u-boot program, C language functions are associated with the Python interpreter. The Python interpreter parses test cases and executes Python bytecode for eMMC testing, avoiding recompilation and flashing operations.
This enables the direct execution of test cases on the testing platform, improving the testing efficiency of eMMC products and reducing development difficulty and execution time.
Smart Images
Figure CN121237164A_ABST
Abstract
Description
TECHNICAL FIELD
[0001] The present application relates to the technical field of storage chips, and particularly relates to an eMMC testing method and device, equipment and a storage medium. BACKGROUND
[0002] Before an eMMC product is released, it needs to be tested by an internal verification platform. The internal verification platform is developed on u-boot. After entering the u-boot, a command line is automatically entered, and a test case is started through the command line. The test case sends various commands to the eMMC for testing. However, since the test case is integrated in the source code of the u-boot, each time the test case is updated, the entire u-boot needs to be recompiled and the u-boot image needs to be reprogrammed, so that the test case cannot be integrated in real time, thereby causing low eMMC testing efficiency. SUMMARY
[0003] Embodiments of the present application provide an eMMC testing method, device, equipment and storage medium, which can effectively improve the testing efficiency of an eMMC product.
[0004] In a first aspect, embodiments of the present application provide an eMMC testing method applied to a test platform, wherein the test platform is in communication connection with a server and an eMMC product respectively, the test platform corresponds to an initial u-boot program, the initial u-boot program has a C language function for operating the eMMC product, and the method comprises the following steps.
[0005] Integrating a python interpreter into the initial u-boot program to obtain a target u-boot program, wherein the C language function in the target u-boot program is associated with the python interpreter;
[0006] Starting the target u-boot program after the test platform is powered on;
[0007] When a test case issued by the server is received, the python interpreter parses the test case to obtain Python bytecode, executes the Python bytecode to test the eMMC product, and obtains a test result, wherein the test case includes a packaging function capable of calling the C language function, and the test case is a python test case;
[0008] Sending the test result to the server.
[0009] In some embodiments, the initial u-boot program corresponds to a u-boot source code tree and a build configuration file. Integrating a Python interpreter into the initial u-boot program yields the target u-boot program, including:
[0010] Add the source code corresponding to the Python interpreter to the u-boot source code tree;
[0011] Add the configuration parameters corresponding to the Python interpreter to the build configuration file;
[0012] Construct a low-level interface, which associates the Python interpreter with the C language functions;
[0013] Add new initialization code to the initialization function corresponding to the initial u-boot program. The initialization code represents the code used to initialize the Python interpreter to obtain the target u-boot program.
[0014] In some embodiments, the Python interpreter parses the test cases to obtain Python bytecode, including:
[0015] Save the test cases issued by the server into memory and determine the target byte length of the test cases;
[0016] When the total number of bytes of all data in the memory reaches the target byte length, the Python interpreter retrieves the test case from the memory and parses the test case to obtain the Python bytecode.
[0017] In some embodiments, before the Python interpreter parses the test cases to obtain Python bytecode, the method further includes:
[0018] Perform network initialization on the test platform;
[0019] Initialize the Python interpreter.
[0020] Secondly, embodiments of this application provide a testing platform that is communicatively connected to a server and an eMMC product. The testing platform includes an initial u-boot program containing C language functions for operating the eMMC product. The testing platform further includes:
[0021] A data processing module is used to integrate the Python interpreter into the initial u-boot program to obtain a target u-boot program, wherein the C language functions in the target u-boot program are associated with the Python interpreter;
[0022] The program startup module is used to start the target u-boot program when the test platform is powered on;
[0023] The eMMC testing module is used to, upon receiving test cases from the server, have the Python interpreter parse the test cases to obtain Python bytecode, execute the Python bytecode to test the eMMC product, and obtain test results. The test cases include wrapper functions that can call C language functions, and the test cases are Python test cases.
[0024] The test result feedback module is used to send the test results to the server.
[0025] In some embodiments, the initial u-boot program corresponds to a u-boot source code tree and a build configuration file, and the data processing module includes:
[0026] The first processing module is used to add the source code corresponding to the Python interpreter to the u-boot source code tree;
[0027] The second processing module is used to add the configuration parameters corresponding to the Python interpreter to the build configuration file;
[0028] The third processing module is used to construct the underlying interface, which is associated with the Python interpreter and the C language functions.
[0029] The fourth processing module is used to add new initialization code to the initialization function corresponding to the initial u-boot program. The initialization code represents the code used to initialize the Python interpreter to obtain the target u-boot program.
[0030] In some embodiments, the eMMC testing module includes:
[0031] The test case receiving module is used to save the test cases sent by the server into memory and determine the target byte length of the test cases;
[0032] The test case parsing module is used to retrieve the test cases from the memory and parse the test cases to obtain the Python bytecode when the total number of bytes of all data in the memory reaches the target byte length.
[0033] In some embodiments, it also includes:
[0034] An initialization module is used to initialize the network of the test platform and the Python interpreter.
[0035] Thirdly, embodiments of this application provide a control device, including at least one control processor and a memory for communicatively connecting to the at least one control processor; the memory stores instructions executable by the at least one control processor, which, when executed by the at least one control processor, enable the at least one control processor to perform the eMMC testing method as described in the first aspect.
[0036] Fourthly, embodiments of this application also provide a computer-readable storage medium storing computer-executable instructions for performing the eMMC testing method as described in the first aspect.
[0037] This application provides an eMMC testing method, apparatus, device, and storage medium. The method includes: integrating a Python interpreter into an initial u-boot program to obtain a target u-boot program, wherein the C language functions in the target u-boot program are associated with the Python interpreter; starting the target u-boot program after the test platform is powered on; upon receiving test cases from the server, the Python interpreter parses the test cases to obtain Python bytecode, executes the Python bytecode to test the eMMC product, and obtains test results, wherein the test cases include wrapper functions that can call the C language functions, and the test cases are Python test cases; and sending the test results to the server. According to the solution provided by this application, after starting the target u-boot program and receiving the issued test cases, the test cases can be directly executed on the u-boot of the test platform to test the eMMC product. Compared to the time-consuming operation of recompiling and burning test cases to the u-boot, this method enables real-time testing of test cases, improving the testing efficiency of eMMC products. Attached Figure Description
[0038] Figure 1 This is a flowchart of the steps of an eMMC testing method provided in one embodiment of this application;
[0039] Figure 2 This is a schematic diagram of an eMMC testing method provided in another embodiment of this application;
[0040] Figure 3 This is a structural diagram of a control device provided in another embodiment of this application. Detailed Implementation
[0041] To make the objectives, technical solutions, and advantages of this application clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the scope of this application.
[0042] It is understandable that although functional modules are divided in the device schematic diagram and a logical order is shown in the flowchart, in some cases, the steps shown or described may be performed in a different order than the module division in the device or the order in the flowchart. The terms "first," "second," etc., in the specification, claims, or the aforementioned drawings are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence.
[0043] Before release, eMMC products need to undergo testing on an internal verification platform. This platform is developed on u-boot. Entering u-boot automatically leads to the command line, where test cases are launched. These test cases combine various commands and are sent to the eMMC for testing. However, because the test cases are integrated into the u-boot source code, each update to the test cases requires recompiling the entire u-boot and re-flashing the u-boot image. This makes real-time integration of test cases impossible, resulting in low eMMC testing efficiency.
[0044] To address the aforementioned problems, this application provides an eMMC testing method, apparatus, device, and storage medium. The method includes: integrating a Python interpreter into an initial u-boot program to obtain a target u-boot program, wherein the C language functions in the target u-boot program are associated with the Python interpreter; starting the target u-boot program after the test platform is powered on; upon receiving test cases from the server, the Python interpreter parses the test cases to obtain Python bytecode, executes the Python bytecode to test the eMMC product, and obtains test results, wherein the test cases include wrapper functions capable of calling the C language functions, and the test cases are Python test cases; and sending the test results to the server. According to the solution provided by this application, starting the target u-boot program and receiving the issued test cases allows for direct execution of the test cases on the test platform's u-boot to test the eMMC product. Compared to the time-consuming operations of recompiling and burning test cases to the u-boot, this method enables real-time testing of test cases, improving the testing efficiency of eMMC products.
[0045] The embodiments of this application will be further described below with reference to the accompanying drawings.
[0046] refer toFigure 1 , Figure 1 This is a flowchart illustrating the steps of an eMMC testing method provided in one embodiment of this application. The testing platform is communicatively connected to both the server and the eMMC product. The testing platform has an initial u-boot program, which contains C language functions for operating the eMMC product. This embodiment of the application provides an eMMC testing method, which includes, but is not limited to, the following steps:
[0047] Step S10: Integrate the Python interpreter into the initial u-boot program to obtain the target u-boot program, wherein the C language functions in the target u-boot program are associated with the Python interpreter.
[0048] Understandably, since the initial u-boot program is an embedded bare-metal environment without a file system and its corresponding code is in C, the traditional approach requires recompiling the entire u-boot program and re-flashing the u-boot image when new test cases are received. This makes real-time integration of test cases impossible, impacting the testing efficiency of eMMC products. Furthermore, test cases are developed in C, requiring developers to have embedded systems knowledge, placing high demands on test case development and affecting efficiency. Therefore, this application integrates a Python interpreter into the initial u-boot program, enabling Python to call the underlying C functions within the initial u-boot program. This eliminates the need to write test cases in C or compile and flash them to the u-boot, thus providing effective support for improving the execution efficiency of Python test cases later.
[0049] Specifically, in some embodiments, the initial u-boot program corresponds to a u-boot source code tree and a build configuration file, and step S10 includes, but is not limited to, the following steps:
[0050] Step S11: Add the source code corresponding to the Python interpreter to the u-boot source code tree;
[0051] Step S12: Add the configuration parameters corresponding to the Python interpreter to the build configuration file;
[0052] Step S13: Construct the underlying interface, which associates the Python interpreter with C language functions;
[0053] Step S14: Add new initialization code to the initialization function corresponding to the initial u-boot program. The initialization code represents the code used to initialize the Python interpreter, thus obtaining the target u-boot program.
[0054] Specifically, the Python interpreter in this embodiment is MicroPython, which can be determined by those skilled in the art based on actual needs.
[0055] Understandably, in this embodiment, the specific operations for integrating the Python interpreter into the initial u-boot program to obtain the target u-boot program are as follows: adding the source code corresponding to the Python interpreter to the u-boot source code tree, adding the configuration parameters corresponding to the Python interpreter to the build configuration file (u-boot makefile), and building the underlying interface that associates the Python interpreter and C language functions, so that the underlying C language functions involved in testing eMMC products in u-boot are exposed as modules that can be called by Python, thereby enabling Python scripts to directly call the underlying hardware or high-performance C language functions.
[0056] In this way, the Python interpreter encapsulates the underlying eMMC operation interfaces in C language. When developing test cases, Python can be used to call the interfaces provided by C language, thereby connecting the Python language with the underlying C language functions in the u-boot program. This reduces the difficulty of test case development and improves the execution efficiency of test cases.
[0057] Step S20: After the test platform is powered on, the target u-boot program is started.
[0058] Understandably, the target u-boot program corresponds to the do_net_python function, which contains core logic such as waiting / receiving test case scripts from the server, calling the Python interpreter, executing test cases, and returning test results. In this embodiment, the do_net_python function is registered as a u-boot command (net_python) that u-boot can recognize and execute. This allows the u-boot command to be executed after the test platform is powered on and the target u-boot program is started. This enables the execution of operations such as waiting / receiving test case scripts from the server, calling the Python interpreter, executing test cases, and returning test results to complete the testing of the eMMC product.
[0059] Step S30: When the test cases are received from the server, the Python interpreter parses the test cases to obtain Python bytecode, executes the Python bytecode to test the eMMC product, and obtains the test results. The test cases include wrapper functions that can call C language functions, and the test cases are Python test cases.
[0060] Understandably, after receiving the test cases from the server, since the test cases are Python test cases and include wrapper functions that can call C language functions, the Python interpreter can directly interpret the Python test cases to obtain machine code (i.e., Python bytecode) that the test platform can execute. In this way, the test cases can be executed directly on u-boot to call C language functions that can operate the eMMC product, thereby realizing the testing of the eMMC product. After the test is completed, the corresponding test results are obtained. That is, after the test cases are developed, there is no need to compile u-boot. The test cases can be directly integrated into the target machine through the server for execution, which is convenient, fast and improves testing efficiency.
[0061] In addition, in some embodiments, before the Python interpreter parses the test cases to obtain Python bytecode in step S30, the eMMC testing method of this application embodiment also includes, but is not limited to, the following steps:
[0062] Step S31: Initialize the network for the test platform;
[0063] Step S32: Initialize the Python interpreter.
[0064] Understandably, after starting the target u-boot program and before the Python interpreter parses the test cases to obtain Python bytecode, this embodiment performs network initialization on the test platform and initializes the Python interpreter, thereby preparing all the necessary hardware and software environment for the entire automated testing process.
[0065] Specifically, in some embodiments, step S30 involves the Python interpreter parsing the test cases to obtain Python bytecode, including but not limited to the following steps:
[0066] Step S33: Save the test cases sent by the server into memory and determine the target byte length of the test cases;
[0067] Step S34: When the total number of bytes of all data in memory reaches the target byte length, the Python interpreter retrieves the test cases from memory and parses the test cases to obtain Python bytecode.
[0068] Specifically, before the server sends out a test case, it will first send out the target byte length corresponding to that test case.
[0069] Understandably, reference Figure 2In this embodiment, after receiving the test cases from the server, the test cases are first stored in memory. The execution of the test cases is flagged by whether the reception of the test cases has been completed. When the total number of bytes in memory reaches the target byte length, it indicates that the current test case has been received successfully, triggering the Python interpreter to proceed with the next step of test case parsing. If the number of bytes in memory has not reached the target byte length, it indicates that the current test case has not been received successfully, and the process must wait for the test cases to be received before proceeding to the next step. This avoids the possibility of incomplete or corrupted test cases in memory due to network uncertainties (including network latency, jitter, and packet loss), ensuring the validity of the test results.
[0070] Step S40: Send the test results to the server.
[0071] Understandably, after executing all the test cases, the test results are fed back to the server to complete the testing of the eMMC product.
[0072] In addition, this application also discloses a testing platform that is communicatively connected to both a server and an eMMC product. The testing platform includes an initial u-boot program containing C language functions for operating the eMMC product. The testing platform also includes:
[0073] The data processing module is used to integrate the Python interpreter into the initial u-boot program to obtain the target u-boot program, wherein the C language functions in the target u-boot program are associated with the Python interpreter;
[0074] The program startup module is used to start the target u-boot program when the test platform is powered on;
[0075] The eMMC testing module is used to receive test cases from the server, parse the test cases to obtain Python bytecode, execute the Python bytecode to test the eMMC product, and obtain the test results. The test cases include wrapper functions that can call C language functions, and the test cases are Python test cases.
[0076] The test result feedback module is used to send the test results to the server.
[0077] In some embodiments, the initial u-boot program corresponds to a u-boot source code tree and a build configuration file, and the data processing module includes:
[0078] The first processing module is used to add the source code corresponding to the Python interpreter to the u-boot source code tree;
[0079] The second processing module is used to add configuration parameters corresponding to the Python interpreter to the build configuration file;
[0080] The third processing module is used to build the underlying interface, which is associated with the Python interpreter and C language functions.
[0081] The fourth processing module is used to add new initialization code to the initialization function corresponding to the initial u-boot program. The initialization code represents the code used to initialize the Python interpreter, thus obtaining the target u-boot program.
[0082] In some embodiments, the eMMC testing module includes:
[0083] The test case receiving module is used to save the test cases sent by the server into memory and determine the target byte length of the test cases;
[0084] The test case parsing module is used when the total number of bytes of data in memory reaches the target byte length. The Python interpreter then retrieves test cases from memory and parses them to obtain Python bytecode.
[0085] In some embodiments, the testing platform further includes:
[0086] The initialization module is used to initialize the network of the test platform and the Python interpreter.
[0087] It should be noted that the specific implementation of the testing platform is basically the same as the specific implementation of the eMMC testing method described above, and will not be repeated here.
[0088] like Figure 3 As shown, Figure 3 This is a structural diagram of a control device provided in one embodiment of this application. The present invention also provides a control device 300, comprising:
[0089] The processor 310 can be implemented using a general-purpose central processing unit (CPU), microprocessor, application specific integrated circuit (ASIC), or one or more integrated circuits, and is used to execute relevant programs to implement the technical solutions provided in the embodiments of this application.
[0090] The memory 320 can be implemented as a read-only memory (ROM), static storage device, dynamic storage device, or random access memory (RAM). The memory 320 can store the operating system and other applications. When the technical solutions provided in the embodiments of this specification are implemented through software or firmware, the relevant program code is stored in the memory 320 and is called and executed by the processor 310 using the eMMC testing method of the embodiments of this application.
[0091] Input / output interface 330 is used to realize information input and output;
[0092] The communication interface 340 is used to enable communication and interaction between this device and other devices. Communication can be achieved through wired means (such as USB, network cable, etc.) or wireless means (such as mobile network, WIFI, Bluetooth, etc.).
[0093] Bus 350 transmits information between various components of the device (e.g., processor 310, memory 320, input / output interface 330, and communication interface 340);
[0094] The processor 310, memory 320, input / output interface 330 and communication interface 340 are connected to each other within the device via bus 350.
[0095] In addition, this application embodiment also provides a storage medium, which is a computer-readable storage medium, storing a computer program that, when executed by a processor, implements the above-described eMMC testing method.
[0096] Memory, as a non-transitory computer-readable storage medium, can be used to store non-transitory software programs and non-transitory computer-executable programs. Furthermore, memory may include high-speed random access memory, and may also include non-transitory memory, such as at least one disk storage device, flash memory device, or other non-transitory solid-state storage device. In some embodiments, memory may optionally include memory remotely located relative to the processor, and these remote memories can be connected to the processor via a network. Examples of such networks include, but are not limited to, the Internet, intranets, local area networks, mobile communication networks, and combinations thereof. The device embodiments described above are merely illustrative, and the units described as separate components may or may not be physically separate, and may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs.
[0097] It will be understood by those skilled in the art that all or some of the steps and systems in the methods disclosed above can be implemented as software, firmware, hardware, and suitable combinations thereof. Some or all of the physical components can be implemented as software executed by a processor, such as a central processing unit, digital signal processor, or microprocessor, or as hardware, or as an integrated circuit, such as an application-specific integrated circuit. Such software can be distributed on a computer-readable medium, which can include computer storage media (or non-transitory media) and communication media (or transient media). As is known to those skilled in the art, the term computer storage media includes volatile and non-volatile, removable and non-removable media implemented in any method or technology for storing information (such as computer-readable instructions, data structures, program modules, or other data). Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technologies, CD-ROM, digital versatile disc (DVD) or other optical disc storage, magnetic cartridges, magnetic tape, disk storage or other magnetic storage devices, or any other medium that can be used to store desired information and is accessible to a computer. Furthermore, as is known to those skilled in the art, communication media typically include computer-readable instructions, data structures, program modules, or other data in modulated data signals such as carrier waves or other transmission mechanisms, and may include any information delivery medium.
[0098] The above provides a detailed description of the preferred embodiments of the present invention. However, the present invention is not limited to the above embodiments. Those skilled in the art can make various equivalent modifications or substitutions without departing from the spirit of the present invention. All such equivalent modifications or substitutions are included within the scope defined by the claims of the present invention.
Claims
1. An eMMC testing method, characterized in that, The method is applied to a test platform in communication connection with a server and an eMMC product respectively, the test platform corresponds to an initial u-boot program, the initial u-boot program has C language functions for operating the eMMC product, and the method comprises the following steps: integrating a python interpreter into the initial u-boot program to obtain a target u-boot program, wherein the C language functions in the target u-boot program are associated with the python interpreter; starting the target u-boot program after the test platform is powered on; when a test case issued by the server is received, the python interpreter parses the test case to obtain Python bytecode, executes the Python bytecode to test the eMMC product, and obtains a test result, wherein the test case comprises a packaging function capable of calling the C language functions, and the test case is a python test case; sending the test result to the server.
2. The eMMC test method of claim 1, wherein, The initial u-boot program corresponds to a u-boot source code tree and a build configuration file, the python interpreter is integrated into the initial u-boot program to obtain a target u-boot program, and the method comprises the following steps: adding source code corresponding to the python interpreter to the u-boot source code tree; adding a configuration parameter corresponding to the python interpreter in the build configuration file; building a bottom interface, the bottom interface is associated with the python interpreter and the C language functions; adding new initialization code in an initialization function corresponding to the initial u-boot program, the initialization code represents code for initializing the python interpreter, and the target u-boot program is obtained.
3. The eMMC testing method of claim 1, wherein, The python interpreter parses the test case to obtain Python bytecode, and the method comprises the following steps: saving the test case issued by the server to a memory and determining a target byte length of the test case; when the byte length of all data in the memory reaches the target byte length, the test case is obtained from the memory, and the Python bytecode is obtained by parsing the test case through the python interpreter.
4. The eMMC test method of claim 1, wherein, Before the python interpreter parses the test case to obtain Python bytecode, the method further comprises the following steps: performing network initialization on the test platform; initializing the python interpreter.
5. A test platform characterized by, The test platform is in communication connection with a server and an eMMC product respectively, the test platform corresponds to an initial u-boot program, the initial u-boot program has C language functions for operating the eMMC product, and the test platform further comprises the following: a data processing module for integrating a python interpreter into the initial u-boot program to obtain a target u-boot program, wherein the C language functions in the target u-boot program are associated with the python interpreter; A program starting module is configured to start the target u-boot program when the test platform is powered on. An eMMC test module is configured to receive the test case sent by the server, parse the test case by the python interpreter to obtain Python bytecode, execute the Python bytecode to test the eMMC product, and obtain a test result, wherein the test case includes a packaging function capable of calling the C language function, and the test case is a python test case. A test result feedback module is configured to send the test result to the server.
6. The test platform of claim 5, wherein, The initial u-boot program corresponds to a u-boot source code tree and a build configuration file, and the data processing module includes: A first processing module is configured to add the source code corresponding to the python interpreter to the u-boot source code tree; A second processing module is configured to add the configuration parameters corresponding to the python interpreter to the build configuration file; A third processing module is configured to build a bottom interface, wherein the bottom interface is associated with the python interpreter and the C language function; A fourth processing module is configured to add new initialization code to the initialization function corresponding to the initial u-boot program, wherein the initialization code represents code for initializing the python interpreter, and the target u-boot program is obtained.
7. The test platform of claim 5, wherein, The eMMC test module includes: A test case receiving module is configured to save the test case sent by the server to the memory and determine the target byte length of the test case; A test case parsing module is configured to obtain the test case from the memory by the python interpreter and parse the test case to obtain the Python bytecode when the byte length of all data in the memory reaches the target byte length.
8. The test platform of claim 5, wherein, Further comprising: An initialization module is configured to perform network initialization on the test platform and initialize the python interpreter.
9. A control device characterized by comprising: The computer readable storage medium stores computer executable instructions, and the computer executable instructions are used to make the computer execute the eMMC test method in any one of claims 1 to 4.
10. A computer-readable storage medium, characterized in that, The computer readable storage medium stores computer executable instructions, and the computer executable instructions are used to make the computer execute the eMMC test method in any one of claims 1 to 4.