Pressure test method, device and equipment of MTK platform, storage medium and product

Abstract

The invention relates to the technical field of firmware upgrade testing, in particular to a pressure testing method and device for an MTK platform, equipment, a storage medium and a product. According to the method, manual operation is simulated based on an automatic script, a firmware package is selected, and an upgrading process is executed; based on the tkinter library, creating a user input interface; acquiring test parameters from the user input interface; on the basis of the test parameters, automatic test is performed through the pyautogui library and the subprocess library, so that the efficiency and reliability of the firmware upgrade pressure test are improved.

Description

Technical Field

[0001] The present application relates to the technical field of firmware upgrade testing, and in particular to a stress testing method, device, equipment, storage medium and product for an MTK platform. Background Art

[0002] With the rapid development of smart mobile terminals, software upgrades of terminal devices have become more and more frequent, especially the process involving firmware upgrades, which directly affects the stability and function expansion of the terminal. In the existing firmware upgrade process, it is usually necessary to manually select the firmware package and perform the upgrade operation through tools. For example, mobile terminals on the MTK (MediaTek) platform usually rely on tools such as FlashTool to manually complete firmware upgrades. However, with the increase in the scale of devices and the increase in the frequency of upgrades, the manual operation method has gradually shown many shortcomings. "Inefficiency" is a major problem of manual operation. In the process of firmware upgrade, operators need to repeatedly select firmware, click upgrade and other processes, which makes the application of stress testing in large-scale firmware upgrade scenarios impractical. Especially for continuous stress testing, the workload of manual operation is very large and prone to errors; secondly, the consistency of test results is difficult to guarantee. Due to different operator experience and operation methods, manual operation is prone to inconsistency, affecting the stability and reliability of the test. Under different test conditions, the manual upgrade steps may produce subtle differences, resulting in poor repeatability of test results and difficulty in accurately reflecting the impact of firmware upgrades on terminal devices; the existing manual operation method cannot be well integrated with the automated test platform and lacks the necessary support of automated tools. This makes it difficult for manual stress testing to connect with modern automated testing tools and processes, increasing the complexity and maintenance costs of the testing process. Therefore, how to improve the efficiency and reliability of firmware upgrade stress testing has become an urgent problem to be solved. Summary of the invention

[0003] The main purpose of this application is to provide a stress testing method, device, equipment, storage medium and product for an MTK platform, aiming to solve the technical problem of how to improve the efficiency and reliability of firmware upgrade stress testing.

[0004] To achieve the above object, the present application provides a stress testing method for an MTK platform, the method comprising the following steps:

[0005] Simulate manual operations based on automated scripts to select firmware packages and execute upgrade processes;

[0006] Create a user input interface based on the tkinter library;

[0007] Acquire test parameters from the user input interface;

[0008] Based on the test parameters, automated testing is performed using the pyautogui library and the subprocess library.

[0009] In one embodiment, before the step of simulating manual operation based on the automated script, selecting a firmware package and executing the upgrade process, the step further includes:

[0010] Divide the automation script into modules according to the functions of the automation script;

[0011] Based on the result of module division, the execution flow of the automation script is planned.

[0012] In one embodiment, the automation script includes a firmware selection module, an upgrade execution module, and a log recording module. The steps of simulating manual operations based on the automation script, selecting a firmware package, and executing the upgrade process include:

[0013] Based on the firmware selection module, simulate manual operation to select a firmware package;

[0014] Based on the logging module, record the time and timestamp of the test process;

[0015] Based on the upgrade execution module, a firmware upgrade process is executed.

[0016] In one embodiment, the step of creating a user input interface based on the tkinter library includes:

[0017] Import the tkinter library and initialize the main window;

[0018] Determine the window layout according to the set layout data;

[0019] Add labels and input boxes to the window after layout, and define functions to get parameters;

[0020] Create a click button, and bind the click button to the function for obtaining parameters;

[0021] Start the main event loop of the tkinter library to obtain the user input interface.

[0022] In one embodiment, the step of obtaining the test parameters from the user input interface includes:

[0023] Acquire text data input by the user from the user input interface;

[0024] Based on a preset format standard, the text data is formatted to obtain standard text data;

[0025] Based on a preset data range, verifying the validity of the standard text data;

[0026] The verified standard text data is used as the test parameter.

[0027] In one embodiment, the step of performing automated testing based on the test parameters through the pyautogui library and the subprocess library includes:

[0028] Perform firmware upgrade by simulating keyboard and mouse operations through the pyautogui library;

[0029] The logs during the upgrade process are recorded based on the subprocess library.

[0030] In addition, to achieve the above purpose, the present application also proposes a pressure testing device for the MTK platform, the pressure testing device for the MTK platform comprising:

[0031] A simulation module is used to simulate manual operations based on automated scripts, select firmware packages, and execute upgrade processes;

[0032] Input interface creation module, used to create user input interface based on tkinter library;

[0033] A parameter acquisition module, used to acquire test parameters from the user input interface;

[0034] The test module is used to perform automated testing based on the test parameters through the pyautogui library and the subprocess library.

[0035] In addition, to achieve the above-mentioned purpose, the present application also proposes a stress testing device for the MTK platform, the device comprising: a memory, a processor, and a stress testing program for the MTK platform stored in the memory and executable on the processor, the stress testing program for the MTK platform being configured to implement the steps of the stress testing method for the MTK platform as described above.

[0036] In addition, to achieve the above objectives, the present application also proposes a storage medium, on which a stress test program for the MTK platform is stored. When the stress test program for the MTK platform is executed by a processor, the steps of the stress test method for the MTK platform as described above are implemented.

[0037] In addition, to achieve the above-mentioned purpose, the present application also proposes a computer program product, which includes a computer program, and when the computer program is executed by a processor, the steps of the stress testing method of the MTK platform as described above are implemented.

[0038] This application simulates manual operations based on automated scripts, selects firmware packages and executes upgrade processes; creates a user input interface based on the tkinter library; obtains test parameters from the user input interface; and performs automated testing based on test parameters through the pyautogui library and the subprocess library. This application simulates manual operations through automated scripts, avoiding the inefficiency and inconsistency of manually selecting firmware packages and executing upgrade processes, significantly improving test efficiency; using the tkinter library to create a user input interface simplifies the configuration of test parameters, making operations more convenient and flexible; by obtaining test parameters from the user interface and combining the pyautogui library and the subprocess library to achieve full automated testing, the repeatability and accuracy of the test are ensured, while reducing the possibility of manual intervention and errors, effectively improving the efficiency and reliability of firmware upgrade stress testing. BRIEF DESCRIPTION OF THE DRAWINGS

[0039] Figure 1 This is a flow chart of the first embodiment of the stress testing method of the MTK platform of the present application;

[0040] Figure 2 This is a schematic diagram of a sub-flow in the second embodiment of the stress testing method of the MTK platform of the present application;

[0041] Figure 3 This is a schematic diagram of a sub-flow in the third embodiment of the stress testing method of the MTK platform of the present application;

[0042] Figure 4 This is a schematic diagram of the module structure of the pressure testing device of the MTK platform according to an embodiment of the present application;

[0043] Figure 5 This is a schematic diagram of the device structure of the hardware operating environment involved in the stress testing method of the MTK platform in the embodiment of the present application.

[0044] The realization of the purpose, functional features and advantages of this application will be further explained in conjunction with embodiments and with reference to the accompanying drawings. DETAILED DESCRIPTION

[0045] It should be understood that the specific embodiments described herein are only used to explain the present application and are not used to limit the present application.

[0046] In order to better understand the technical solution of the present application, a detailed description will be given below in conjunction with the accompanying drawings and specific implementation methods.

[0047] It should be noted that with the rapid development of smart mobile terminals, the software upgrade of terminal devices has become more and more frequent, especially the process involving firmware upgrade, which directly affects the stability and function expansion of the terminal. In the existing firmware upgrade process, it is usually necessary to manually select the firmware package and perform the upgrade operation through tools. For example, mobile terminals on the MTK (MediaTek) platform usually rely on tools such as FlashTool to manually complete the firmware upgrade. However, with the increase in the scale of equipment and the increase in the frequency of upgrades, the manual operation method has gradually shown many shortcomings. "Low efficiency" is a major problem of manual operation. In the process of firmware upgrade, operators need to repeatedly select firmware, click upgrade and other processes, which makes the application of stress testing in large-scale firmware upgrade scenarios impractical. Especially for continuous stress testing, the workload of manual operation is very large and prone to errors; secondly, the consistency of test results is difficult to guarantee. Due to different operator experience and operation methods, manual operation is prone to inconsistency, affecting the stability and reliability of the test. Under different test conditions, the manual upgrade steps may produce subtle differences, resulting in poor repeatability of test results and difficulty in accurately reflecting the impact of firmware upgrades on terminal devices; the existing manual operation method cannot be well integrated with the automated test platform and lacks the necessary support of automated tools. This makes it difficult for manual stress testing to connect with modern automated testing tools and processes, increasing the complexity and maintenance costs of the testing process. Therefore, how to improve the efficiency and reliability of firmware upgrade stress testing has become an urgent problem to be solved.

[0048] The main solution of this application is: simulate manual operation based on automated scripts, select firmware packages and execute upgrade processes; create a user input interface based on the tkinter library; obtain test parameters from the user input interface; and perform automated testing based on the test parameters through the pyautogui library and the subprocess library.

[0049] This application simulates manual operations through automated scripts, avoiding the inefficiency and inconsistency of manually selecting firmware packages and executing upgrade processes, and significantly improving test efficiency; it uses the tkinter library to create a user input interface, simplifies the configuration of test parameters, and makes operations more convenient and flexible; by obtaining test parameters from the user interface and combining the pyautogui library and the subprocess library to achieve full automated testing, it ensures the repeatability and accuracy of the test, while reducing the possibility of manual intervention and errors, and effectively improving the efficiency and reliability of firmware upgrade stress testing.

[0050] It should be noted that the execution subject of the method of this embodiment can be a computing service device with data processing, network communication and program running functions, or it can be a stress test device of the above MTK platform with the same or similar functions. This embodiment and the following embodiments will be described by taking the stress test device of the MTK platform as an example.

[0051] Based on this, the first embodiment of the stress testing method of the MTK platform of this application is proposed, please refer to Figure 1 , Figure 1 This is a flow chart of the first embodiment of the stress testing method of the MTK platform of the present application.

[0052] In this embodiment, the stress testing method of the MTK platform includes the following steps:

[0053] S1: Simulates manual operations based on automated scripts, selects firmware packages and executes the upgrade process;

[0054] It should be noted that an automated script refers to an automated operation process implemented by writing a computer program. The script can simulate manual operation and perform a series of predetermined tasks without human intervention. In this step, the automated script is used to simulate the manual operation of firmware package selection and upgrade. Manual operation refers to the operation of manually performing a certain process, such as selecting a firmware package, clicking an upgrade button, etc. Such operations are usually completed through the user's input device (such as a mouse, keyboard), and in this application, automated scripts are used to replace manual operations. A firmware package refers to a software file package used to upgrade the firmware of a mobile terminal, including updates, repairs, and new functions of the operating system. In the upgrade process of the MTK platform, the firmware package is the core file in the upgrade process. The upgrade process refers to a series of steps for firmware upgrade after selecting a firmware package. It usually includes operations such as firmware writing, restarting, and verification of the device to ensure that the new firmware is successfully installed on the device.

[0055] Specifically, first of all, the writing of the automation script needs to take into account the automation of each manual step in the firmware upgrade process. By writing a script, the process of the user using a tool (such as FlashTool) to select the firmware package and perform the upgrade is simulated. The script first automatically opens the firmware upgrade tool and simulates the user's manual firmware selection steps. During this process, the script selects the predetermined firmware package path by simulating mouse and keyboard input, and then performs a "confirm" or "select" operation. This step realizes the complete automation of the manual firmware package selection process.

[0056] Furthermore, the automated script will continue to simulate the operations of the upgrade process. The script performs the firmware upgrade by calling external tools or interacting directly with the system. The specific process may include clicking the "Start Upgrade" button, monitoring the progress bar during the upgrade process, and recording the system log during the upgrade process. After the upgrade is completed, the script will restart the device through simulated operations and perform corresponding verification operations after the firmware is successfully upgraded to ensure that the upgrade is successful. This process does not require human intervention, realizes the automation of the entire process, and reduces operational errors that may be caused by human factors.

[0057] By using automated scripts to simulate manual operations, labor costs are reduced and the efficiency of firmware upgrade testing is improved. Automated operations can ensure the standardization and consistency of firmware package selection and upgrade processes, avoiding test failures or test data deviations caused by human operational errors or inconsistencies. Secondly, automated scripts can quickly execute the firmware upgrade process, significantly reducing the time spent on repetitive work, especially when conducting large-scale, multi-round stress tests, its efficiency advantage is particularly obvious. In addition, automated operations reduce direct human intervention in equipment and reduce the risk of equipment damage caused by improper operation. Overall, the use of automated scripts effectively improves the accuracy, stability and repeatability of firmware upgrade stress testing.

[0058] S2: Create a user input interface based on the tkinter library;

[0059] It should be noted that the tkinter library is a graphical user interface (GUI) toolkit in the Python standard library, which is used to create interactive controls such as windows, input boxes, buttons, etc., to help developers create graphical user interfaces. In this step, tkinter is used to generate an interface for user input parameters. The user input interface refers to a graphical interface for users to interact with computer programs. Users enter test parameters such as waiting time, number of test cycles, etc. through this interface. The parameters will be used to control the subsequent automated test process.

[0060] Specifically, first, the program creates the main window by calling the tkinter library. This window is the core container of the entire user input interface, which is used to place and manage other controls. By adding controls such as labels, input boxes, buttons, etc. in the window, users can clearly see the parameters that need to be entered and interact through the corresponding input boxes. For example, in order to enter the "waiting time" and "number of test cycles", the corresponding labels will be displayed on the interface to prompt the user, and an input box will be placed next to the label for the user to enter a specific value. This process is implemented by calling components such as Label and Entry in tkinter. The layout of the user interface can be adjusted through layout managers such as pack and grid to ensure that the interface is neat and beautiful.

[0061] Furthermore, after the user interface is created, a submit button needs to be defined for the user to confirm submission after entering the parameters. The button is bound to a parameter acquisition function. When the user clicks the button, the program reads the parameters entered by the user from the input box and performs necessary format conversion and verification. The obtained parameter values ​​will be passed as input to the subsequent automated testing process. In this process, the tkinter Button control is responsible for handling user click events, and the get() method is used to obtain the specific value entered by the user from the input box. The whole process ensures that users can easily complete the input of test parameters through a simple graphical interface, which greatly simplifies the operation steps.

[0062] By creating a user input interface based on the tkinter library, the interaction between the user and the test program is simplified, making parameter input more intuitive and convenient. Compared with the traditional command line input method, the graphical interface enables non-technical users to easily configure test parameters, lowering the operating threshold. Users can directly enter specific test parameters (such as waiting time and number of test cycles) through the interface, avoiding problems caused by input format or parameter passing errors, and improving the friendliness and reliability of the program. In addition, the use of the tkinter library allows the program to be expanded and maintained more flexibly. For example, if more parameter items need to be added or the interface layout needs to be modified later, it can be achieved through simple code adjustments, thereby improving the scalability and maintenance efficiency of the system. In general, this step greatly optimizes the user experience and ensures the accuracy of parameter input and the convenience of operation.

[0063] S3: Acquire test parameters from the user input interface;

[0064] It should be noted that test parameters refer to input variables used to control the test process, such as waiting time (indicating the delay time before performing certain operations) and the number of test cycles (indicating the number of times the test is repeated). These parameters directly affect the execution of automated testing.

[0065] Specifically, first, the user enters the relevant test parameters through the input interface created by tkinter. In the interface, each parameter that requires user input has a corresponding input box (such as Entry). The user sees a prompt on the interface (such as "wait time" or "number of test cycles") and enters the specific value into the input box. After completing the input of all parameters, the user clicks the "Submit" button, indicating that the input parameters are ready to be passed to the program.

[0066] Furthermore, the program reads the user input value from each input box by calling the get() method of the tkinter input box. These values ​​are usually in string format, so they need to be further processed and verified. The program will convert these strings into appropriate data types (such as integers or floating point numbers) and perform data validity checks to ensure that the input parameters meet the expected format and range (for example, the waiting time should be a non-negative integer, and the number of test cycles should also be a positive integer). After verification, these parameters will be used as input for the subsequent automated test process to control the specific execution conditions of the firmware upgrade.

[0067] By obtaining test parameters from the user input interface, the program can flexibly receive user-customized test requirements, improving the flexibility and controllability of the test process. Compared with hard-coded parameters, users can dynamically adjust test parameters according to different test scenarios and requirements to ensure the diversity and pertinence of the test. At the same time, user interface input reduces human errors, because the program will verify the parameters entered by the user to avoid invalid or erroneous data input, thereby improving the reliability of the test process. In addition, this method of collecting parameters through a graphical interface is more intuitive and reduces the complexity of operation, allowing non-technical users to easily configure complex test conditions, thereby further improving the ease of use and overall efficiency of the system.

[0068] S4: Based on the test parameters, automated testing is performed using the pyautogui library and the subprocess library.

[0069] It should be noted that the pyautogui library is a Python library for controlling the keyboard and mouse, which can simulate user operations such as clicking buttons, moving cursors, keyboard input, etc. In this step, pyautogui is used to simulate manual operations to automate the interactive steps in the firmware upgrade process. The subprocess library is a standard library in Python that is used to start and interact with operating system processes. In this step, the subprocess library is used to run external programs or tools (such as firmware upgrade tools) and capture output or log information in real time to ensure the effectiveness of the automated test process.

[0070] Specifically, the automated test process is started based on the test parameters obtained from the user interface. The pyautogui library is used to simulate the user's mouse clicks and keyboard operations. First, the interface of the firmware upgrade tool is located, the mouse is simulated to move to the firmware selection box, and the specified firmware package is selected. Next, the "Upgrade" button is simulated to start the upgrade process. The entire process is controlled by reading test parameters, such as waiting time and number of test cycles, which can control the execution frequency of the operation and the pause time in the process. In this process, pyautogui's mouse clicks, keyboard input and other functions simulate manual operations to ensure that the firmware upgrade operation is performed as expected.

[0071] Furthermore, the subprocess library is used to start external programs related to firmware upgrades and capture their output logs in real time. For example, the subprocess can call the system's command line tool to execute the firmware upgrade program and record the output information (such as upgrade progress, success or failure status) in real time in the log file. This process is controlled by test parameters. The program can repeat the firmware upgrade operation multiple times according to the number of test cycles set by the user, and automatically analyze the log after each test to determine the success or failure of the firmware upgrade.

[0072] By combining the pyautogui library and the subprocess library, the entire firmware upgrade process is highly automated. First, the pyautogui library can accurately simulate manual operations, thereby replacing manual mouse clicks and keyboard input, ensuring the standardization and consistency of the firmware upgrade process. Compared with manual operations, automated testing greatly improves test efficiency, especially when performing multiple rounds of stress testing, avoiding errors and delays in manual operations. Secondly, the use of the subprocess library ensures effective control and real-time logging of external programs during automated testing. By capturing the output of the firmware upgrade tool in real time, the system can dynamically monitor the test process, automatically detect and respond to potential errors or abnormal situations, and enhance the reliability and traceability of the test. Overall, this step not only improves the flexibility and efficiency of the test through parameterized automated testing processes, but also improves the accuracy and stability of the firmware upgrade test.

[0073] This embodiment simulates manual operation based on automated scripts, selects firmware packages and executes upgrade processes; creates a user input interface based on the tkinter library; obtains test parameters from the user input interface; and performs automated testing based on the test parameters through the pyautogui library and the subprocess library. This embodiment simulates manual operation through automated scripts, avoiding the inefficiency and inconsistency of manually selecting firmware packages and executing upgrade processes, and significantly improving test efficiency; using the tkinter library to create a user input interface simplifies the configuration of test parameters, making operations more convenient and flexible; by obtaining test parameters from the user interface and combining the pyautogui library and the subprocess library to achieve full automated testing, the repeatability and accuracy of the test are ensured, while reducing the possibility of manual intervention and errors, effectively improving the efficiency and reliability of firmware upgrade stress testing.

[0074] Based on the above first embodiment, a second embodiment of the stress testing method of the MTK platform of the present application is proposed. In this embodiment, before step S1, it also includes:

[0075] S1a: dividing the automation script into modules according to the functions of the automation script;

[0076] S1b: Based on the result of module division, plan the execution process of the automation script.

[0077] It should be noted that module partitioning is to decompose complex tasks or functions into smaller, single-function modules. Each module works independently and can cooperate with each other to complete the entire task. This approach helps to improve the structure and maintainability of the system. The execution flow refers to the series of operations performed by the program in a predetermined order or logic at runtime. Each step takes the output of the previous step as input until the task is completed.

[0078] Specifically, when dividing the automation script into modules, developers need to analyze the entire firmware upgrade process and divide it into several independent functional modules. Each module is responsible for a specific task, such as creating a user input interface, obtaining test parameters, simulating firmware upgrade operations, recording and analyzing logs, etc. By dividing complex tasks into modules, each module can focus on a single function and communicate with other modules through interfaces. Module division not only simplifies the development process, but also facilitates future maintenance and functional expansion.

[0079] Furthermore, when planning the execution process of the automation script, it is necessary to arrange the execution order between modules according to the functions of the modules. For example, first start the user interface module and let the user enter the test parameters. Then enter the parameter processing module to verify the legality of the input data. If the input is legal, enter the firmware selection and operation simulation module, simulate manual operation through the pyautogui library, and perform firmware upgrades. Finally, the subprocess library starts the external program for upgrade and records the log. The entire process is based on modules and is executed in sequence until all tests are completed.

[0080] By dividing the automation script into modules, the development and maintenance process of complex tasks is simplified. Each module implements functions independently, which reduces the code coupling, making the program structure clearer and more maintainable. At the same time, the modular design facilitates the expansion and modification of functions. New functions can be easily added or existing functions can be modified without affecting other modules. Secondly, by rationally planning the module execution process, it is ensured that each module can be connected in an orderly manner, and the entire automated testing process is more efficient and stable. In addition, the modular execution process reduces the complexity of the operation, and the execution order or number of repetitions can be flexibly adjusted according to needs, which improves the flexibility and controllability of the test process, thereby greatly improving the overall efficiency and reliability of the firmware upgrade stress test.

[0081] See also Figure 2 , Figure 2 This is a schematic diagram of a sub-flow in the second embodiment of the stress testing method for the MTK platform of the present application.

[0082] like Figure 2 As shown, in this embodiment, the automation script includes a firmware selection module, an upgrade execution module and a log recording module, and step S1 includes:

[0083] S11: Based on the firmware selection module, simulate manual operation to select a firmware package;

[0084] S12: Based on the log recording module, record the time and timestamp of the test process;

[0085] S13: Execute the firmware upgrade process based on the upgrade execution module.

[0086] It should be noted that the firmware selection module refers to the selection of the required firmware package during the firmware upgrade process by simulating manual operations through automated scripts. This module is designed to automatically complete the steps of manually selecting firmware packages by users and reduce human intervention. The logging module is used to record various events and data generated during the test process, including time and timestamp. Through logging, testers can track the entire test process and analyze the execution of each step. The upgrade execution module is responsible for the actual execution of the firmware upgrade process, including a series of operations such as loading firmware packages, writing firmware, and restarting the device. This module ensures the smooth progress of the upgrade process and provides real-time feedback when necessary.

[0087] Specifically, in the process of simulating manual operation to select the firmware package, the automation script simulates the user's operation in the firmware upgrade tool through the pyautogui library or similar tools. For example, first, the script will simulate the mouse moving to the file selection area, open the file dialog box, and then automatically locate the specified firmware package path. Next, the script simulates the user clicking the firmware package and confirming the selection. This process is fully automated, avoiding the tedious operation of manual clicking and selection, while ensuring the accuracy and consistency of the selection. During the test execution, the logging module captures the time and timestamp of key operations in the test process in real time through the subprocess library or other logging tools. This module is responsible for recording the specific time point when each important step (such as firmware selection, upgrade start, upgrade completion, etc.) occurs to ensure the traceability of the test results. The recording of timestamps not only helps analyze the response time and execution efficiency during the test process, but can also be used to trace back possible exceptions in the test. Once the firmware package is successfully selected, the upgrade execution module takes over control. This module interacts directly with the upgrade tool through the script to start the firmware upgrade process. The specific steps include loading the firmware, executing the write, monitoring the upgrade progress, and performing the device restart operation after the upgrade is completed. The upgrade execution module can ensure the automation of the entire upgrade process and capture key events during the upgrade process, such as upgrade progress and results (success or failure), for subsequent analysis.

[0088] The firmware selection module simulates manual operation to select the firmware package. The automated script significantly reduces the workload of manual intervention and ensures the consistency and accuracy of firmware selection, especially when repeated testing is performed multiple times, avoiding the influence of human errors. This module improves the standardization of the test process and ensures that the firmware package selected each time is correct. The logging module provides the time and timestamp of the entire test process, helping testers to understand the execution time and order of each step in detail. This not only improves the traceability of the test results, but also provides data support for analyzing the execution efficiency and discovering potential problems (such as delays in certain steps). Detailed records of the log help to better control and optimize the test process. The upgrade execution module completely takes over the firmware upgrade process through automated scripts, ensuring the efficiency and automation of the upgrade. Automated upgrade execution not only improves test efficiency and reduces the probability of upgrade failure caused by manual operation, but also ensures that the process of each upgrade is consistent, thereby improving the stability and reliability of the test. In addition, this module, combined with logging, can provide a clear execution path for each upgrade process, help discover and solve problems in the upgrade, and ensure the success rate and test quality of the firmware upgrade stress test.

[0089] Based on the above first embodiment, in this embodiment, step S2 includes:

[0090] S21: Import the tkinter library and initialize the main window;

[0091] S22: Determine the window layout according to the set layout data;

[0092] S23: Add labels and input boxes to the window after layout, and define a function to obtain parameters;

[0093] S24: Create a click button, and bind the click button to the function for obtaining parameters;

[0094] S25: Start the main event loop of the tkinter library to obtain the user input interface.

[0095] It should be noted that the main window refers to the graphical window created by the tkinter library, which is the container of all controls. The main window is used to display user interaction components such as labels, input boxes, buttons, etc. Layout data refers to the parameters used to define how the various controls in the user interface (such as labels, input boxes, buttons, etc.) are arranged in the window. The layout manager is responsible for arranging the position of the controls in the interface. The function that gets the parameters refers to the function used to read the value entered by the user from the user input box. This function usually validates the user input and passes the input value to other parts of the program for use. The main event loop is the core mechanism of the tkinter library, which is used to respond to user operations (such as clicks, input, etc.). After the event loop is started, the interface will remain active and wait for user interaction.

[0096] Specifically, importing the tkinter library and initializing the main window is the basis for creating a user input interface. Developers first import the tkinter library and create the main window by calling the ˋTk()ˋ function. This window will serve as a container for all user interface elements. Then, you can set the title and initial size of the window to make the user interface look more friendly and neat. After the main window is initialized, the program will start processing the layout of controls in the window.

[0097] Further, the window layout is determined according to the layout data, and labels and input boxes are added after the layout. The layout data is used to control the position and arrangement of each control (such as labels and input boxes) in the window. Common layout management methods include pack(), grid(), and place(), which can help controls to be arranged in order in the window. After completing the layout setting, the program will add multiple input controls, such as labels (used to prompt users to enter content) and input boxes (for users to enter data). Next, define a function to get parameters, which will be triggered when the user clicks the button, read the user input data from the input box, and verify and process its format. Finally, create a click button and bind it to the function to get parameters. When the user completes the parameter input in the input box, clicking the button will trigger the function, and the program will get the input value from the input box and pass these values ​​to other parts of the program. After completing the binding of the button and the function, the program starts the main event loop of tkinter to keep the window active and wait for the user's input operation. The main event loop will continue to run until the user closes the window or the program ends actively.

[0098] By importing the tkinter library and initializing the main window, the program can create a graphical user interface, making it more intuitive and easy for users to input parameters. The user interface is more user-friendly than the traditional command line method, especially for non-technical personnel, which significantly improves the usability and user experience of the program. Through reasonable layout management, the controls can be arranged in the window in an orderly manner, and the interface is clear and concise, which is convenient for users to input data. The setting of input boxes and buttons enables users to enter and confirm parameters directly on the interface, avoiding the complex input of the command line method, and verifies the user input through the function of obtaining parameters to ensure the legality and accuracy of the input. The start of the main event loop ensures the real-time responsiveness of the user interface, allowing users to interact at any time. The whole process improves the efficiency, flexibility and accuracy of parameter input through a graphical interface, avoids errors that may occur when users enter the command line, and provides a higher operating experience.

[0099] This embodiment simulates manual operation based on automated scripts, selects firmware packages and executes upgrade processes; creates a user input interface based on the tkinter library; obtains test parameters from the user input interface; and performs automated testing based on the test parameters through the pyautogui library and the subprocess library. This embodiment simulates manual operation through automated scripts, avoiding the inefficiency and inconsistency of manually selecting firmware packages and executing upgrade processes, and significantly improving test efficiency; using the tkinter library to create a user input interface simplifies the configuration of test parameters, making operations more convenient and flexible; by obtaining test parameters from the user interface and combining the pyautogui library and the subprocess library to achieve full automated testing, the repeatability and accuracy of the test are ensured, while reducing the possibility of manual intervention and errors, effectively improving the efficiency and reliability of firmware upgrade stress testing.

[0100] Based on the above second embodiment, a third embodiment of the stress testing method of the MTK platform of the present application is proposed. Figure 3 , Figure 3 This is a schematic diagram of a sub-process in the third embodiment of the stress testing method for the MTK platform of the present application.

[0101] In this embodiment, step S3 includes:

[0102] S31: Acquire text data input by the user from the user input interface;

[0103] S32: Based on a preset format standard, convert the text data into a format to obtain standard text data;

[0104] S33: verifying the validity of the standard text data based on a preset data range;

[0105] S34: Using the verified standard text data as the test parameter.

[0106] It should be noted that text data refers to the content entered by the user in the input box, which is usually a value in string format. This text data needs to be further processed in order to be used in the program. The preset format standard refers to the standard required for the data format of the user input, for example, the waiting time should be an integer or floating point number, the number of cycles should be a positive integer, etc. The format standard helps ensure that the input data can be processed normally by the program. Standard text data refers to data that has been formatted to meet the format requirements expected by the program. This data is usually converted from a string to a numeric type (such as an integer or floating point number) for use in the test process. The preset data range refers to the range limit for the standard text data. For example, the waiting time should be a positive number, and the number of cycles must be greater than zero. Verifying the data range helps ensure the legality and rationality of the input.

[0107] Specifically, the text data entered by the user is obtained from the user input interface. When the user enters data in the input box created by tkinter and clicks the submit button, the program reads the text data by calling the get() method of the input box. These data are usually string types and are obtained directly from the input box. The program will obtain all necessary parameters (such as waiting time, number of test cycles, etc.) in turn, and temporarily store these values ​​for further processing. The program will convert the format of the text data entered by the user based on the preset format standard. Since the value entered by the user is a string, the program needs to convert it to a standard format according to the data type requirements (such as integer, floating point, etc.). For example, the waiting time should be converted to a floating point number, and the number of test cycles should be converted to an integer. In this process, the program will perform basic format checks on the input data to ensure that they can be converted correctly. If an error occurs during the conversion process (for example, the user enters a non-numeric character), the program will prompt the user to re-enter.

[0108] Furthermore, after completing the format conversion, the program will verify the validity of the converted standard text data according to the preset data range. For example, the waiting time cannot be a negative number, and the number of test cycles must be a positive integer. The program will check whether each parameter is within the preset range. If any data exceeds the preset range, the program will prompt the user to modify the input data. If all parameters pass the verification, the data is considered to be legal data. Finally, the program will pass the verified standard text data as the final test parameter to the subsequent automated test process. At this point, the test parameters already have the appropriate format and range, which can be used to control the execution process of the firmware upgrade to ensure the accuracy and effectiveness of the test.

[0109] By obtaining text data from the user input interface and performing format conversion and validity verification, it is ensured that the data entered by the user conforms to the format and range expected by the program. This process avoids the interference of incorrect user input on the test process and greatly improves the stability and reliability of the program. Format conversion converts text data into directly usable numerical data to ensure that the program can smoothly process the input parameters. Validation further ensures the rationality of the data and prevents illegal or out-of-range data from entering the test process, which in turn causes test errors or failures. This processing step makes the user's input more flexible, but it is strictly checked and processed after the input to ensure the validity of the input data. At the same time, the process of users entering parameters through the interface becomes more intuitive and easy to operate, reducing the probability of errors and improving the reliability and controllability of the entire test process.

[0110] Based on the above second embodiment, in this embodiment, step S4 includes:

[0111] S41: simulating keyboard and mouse operations through the pyautogui library to perform firmware upgrade;

[0112] S42: Recording logs during the upgrade process based on the subprocess library.

[0113] It should be noted that firmware upgrade refers to updating the device's operating system or underlying software by writing a new firmware package to the device. Firmware upgrades usually need to be performed through specific tools and involve steps such as selecting a firmware package, starting the upgrade, and monitoring the upgrade progress. Logging refers to recording key events, status information, and timestamps output by the tool during the firmware upgrade process. Logs are essential for tracking the upgrade process, discovering problems, and analyzing failures.

[0114] Specifically, during the firmware upgrade process, the automation script simulates the entire process of manual operation through the pyautogui library. First, the script simulates mouse movement and clicks through pyautogui to open the firmware upgrade tool interface. Next, simulate the mouse clicking on the firmware selection box, and select the firmware package file in the specified path through keyboard operations or further mouse clicks. After the firmware package is selected, the script continues to simulate clicking the "Upgrade" button to start the firmware upgrade process. Throughout the process, pyautogui completes all actions originally performed manually through mouse and keyboard operations to ensure that the firmware upgrade process can be executed automatically. The script can also accurately simulate the user's operation steps by controlling the waiting time (for example, waiting for the firmware package to load and displaying the upgrade progress) to ensure a smooth process.

[0115] Furthermore, after starting the firmware upgrade process, the subprocess library is used to start an external firmware upgrade tool and capture its output log. The subprocess library can start the firmware upgrade tool by calling a command line or executing an external program, and record the log information of the upgrade tool during execution in real time. These log information include the progress of the firmware upgrade, success or failure status, and possible error information. The subprocess library redirects these output information to a file or console for subsequent analysis and recording. Through the subprocess library, the script can monitor the key events and status of the upgrade process in real time, and analyze the information in the log after the upgrade is completed to determine whether the upgrade is successful.

[0116] The entire firmware upgrade process is automated by simulating keyboard and mouse operations through the pyautogui library. This approach avoids the uncertainty and human errors caused by manual operations and ensures the standardization and consistency of each upgrade process. The automated simulation operation can accurately reproduce the steps of the user manually performing the firmware upgrade, thereby reducing the operational burden of the tester. Especially when performing multiple rounds of upgrade stress testing, the pyautogui library significantly improves the test efficiency and execution speed. The subprocess library is used to record logs during the upgrade process to ensure the traceability and transparency of the firmware upgrade process. By capturing the output logs of the upgrade tool, testers can understand each event that occurs during the upgrade process in detail, and analyze the success or failure of the upgrade and possible error messages based on this. Log records provide an important basis for future problem analysis, debugging, and improvement. In addition, through the integration of the subprocess library, the script can monitor the upgrade process in real time and respond when necessary, further improving the reliability and accuracy of the test. Overall, this process greatly improves the automation level and controllability of the firmware upgrade process, making large-scale, multi-round firmware upgrade testing more efficient and accurate.

[0117] This embodiment simulates manual operation based on automated scripts, selects firmware packages and executes upgrade processes; creates a user input interface based on the tkinter library; obtains test parameters from the user input interface; and performs automated testing based on the test parameters through the pyautogui library and the subprocess library. This embodiment simulates manual operation through automated scripts, avoiding the inefficiency and inconsistency of manually selecting firmware packages and executing upgrade processes, and significantly improving test efficiency; using the tkinter library to create a user input interface simplifies the configuration of test parameters, making operations more convenient and flexible; by obtaining test parameters from the user interface and combining the pyautogui library and the subprocess library to achieve full automated testing, the repeatability and accuracy of the test are ensured, while reducing the possibility of manual intervention and errors, effectively improving the efficiency and reliability of firmware upgrade stress testing.

[0118] The present application also provides a pressure test device for the MTK platform. Figure 4 , Figure 4 This is a schematic diagram of the module structure of the pressure testing device of the MTK platform according to an embodiment of the present application. The pressure testing device of the MTK platform includes:

[0119] A simulation module 401 is used to simulate manual operations based on an automated script, select a firmware package and execute an upgrade process;

[0120] An input interface creation module 402 is used to create a user input interface based on a tkinter library;

[0121] A parameter acquisition module 403 is used to acquire test parameters from the user input interface;

[0122] The test module 404 is used to perform automated testing based on the test parameters through the pyautogui library and the subprocess library.

[0123] The stress testing device for the MTK platform provided in the embodiment of the present application adopts the stress testing method for the MTK platform in the above embodiment, and can solve the technical problem of how to improve the efficiency and reliability of the firmware upgrade stress test. Compared with the prior art, the beneficial effects of the stress testing device for the MTK platform provided in the embodiment of the present application are the same as the beneficial effects of the stress testing method for the MTK platform provided in the above embodiment, and other technical features in the stress testing device for the MTK platform are the same as the features disclosed in the above embodiment method, which will not be described in detail here.

[0124] The present application provides a stress testing device for an MTK platform, and the stress testing device for the MTK platform includes: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor so that the at least one processor can execute the stress testing method for the MTK platform in the above-mentioned embodiment.

[0125] Reference below Figure 5 , which shows a schematic diagram of the structure of the stress test equipment of the MTK platform suitable for implementing the embodiment of the present application. The stress test equipment of the MTK platform in the embodiment of the present application may include but is not limited to mobile terminals such as mobile phones, laptops, digital broadcast receivers, PDAs (Personal Digital Assistants), PADs (Portable Application Descriptions), PMPs (Portable Media Players), vehicle-mounted terminals (such as vehicle-mounted navigation terminals), etc., and fixed terminals such as digital TVs, desktop computers, etc. Figure 5 The stress test equipment of the MTK platform shown is only an example and should not bring any limitation to the functions and scope of use of the embodiments of the present application.

[0126] like Figure 5As shown, the stress test equipment of the MTK platform may include a processing device 1001 (such as a central processing unit, a graphics processor, etc.), which can perform various appropriate actions and processes according to the program stored in the read-only memory (ROM: Read Only Memory) 1002 or the program loaded from the storage device 1003 to the random access memory (RAM: Random Access Memory) 1004. In RAM1004, various programs and data required for the operation of the stress test equipment of the MTK platform are also stored. The processing device 1001, ROM1002 and RAM1004 are connected to each other via a bus 1005. The input / output (I / O) interface 1006 is also connected to the bus. Typically, the following systems can be connected to the I / O interface 1006: input devices 1007 including, for example, a touch screen, a touchpad, a keyboard, a mouse, an image sensor, a microphone, an accelerometer, a gyroscope, etc.; output devices 1008 including, for example, a liquid crystal display (LCD), a speaker, a vibrator, etc.; storage devices 1003 including, for example, a magnetic tape, a hard disk, etc.; and communication devices 1009. The communication device 1009 can allow the stress test equipment of the MTK platform to communicate wirelessly or wired with other devices to exchange data. Although the stress test equipment of the MTK platform with various systems is shown in the figure, it should be understood that it is not required to implement or have all the systems shown. More or fewer systems may be implemented or have alternatively.

[0127] In particular, according to the embodiments disclosed in the present application, the process described above with reference to the flowchart can be implemented as a computer software program. For example, the embodiments disclosed in the present application include a computer program product, which includes a computer program carried on a computer-readable medium, and the computer program includes a program code for executing the method shown in the flowchart. In such an embodiment, the computer program can be downloaded and installed from a network through a communication device, or installed from a storage device 1003, or installed from a ROM 1002. When the computer program is executed by the processing device 1001, the above-mentioned functions defined in the method of the embodiment disclosed in the present application are executed.

[0128] The stress test device of the MTK platform provided by the present application adopts the stress test method of the MTK platform in the above embodiment, which can solve the technical problem of how to improve the efficiency and reliability of the firmware upgrade stress test. Compared with the prior art, the beneficial effects of the stress test device of the MTK platform provided by the present application are the same as the beneficial effects of the stress test method of the MTK platform provided by the above embodiment, and other technical features of the stress test device of the MTK platform are the same as the features disclosed in the method of the previous embodiment, which will not be repeated here.

[0129] It should be understood that the various parts disclosed in this application can be implemented by hardware, software, firmware or a combination thereof. In the description of the above embodiments, specific features, structures, materials or characteristics can be combined in any one or more embodiments or examples in a suitable manner.

[0130] The above is only a specific implementation of the present application, but the protection scope of the present application is not limited thereto. Any person skilled in the art who is familiar with the present technical field can easily think of changes or substitutions within the technical scope disclosed in the present application, which should be included in the protection scope of the present application. Therefore, the protection scope of the present application should be based on the protection scope of the claims.

[0131] The present application provides a computer-readable storage medium having computer-readable program instructions (ie, computer programs) stored thereon, and the computer-readable program instructions are used to execute the stress testing method of the MTK platform in the above-mentioned embodiment.

[0132] The computer-readable storage medium provided in the present application may be, for example, a USB flash drive, but is not limited to electrical, magnetic, optical, electromagnetic, infrared, or semiconductor systems, systems or devices, or any combination of the above. More specific examples of computer-readable storage media may include, but are not limited to: an electrical connection with one or more wires, a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the above. In this embodiment, the computer-readable storage medium may be any tangible medium containing or storing a program that can be used by or in combination with an instruction execution system, system or device. The program code contained on the computer-readable storage medium may be transmitted using any appropriate medium, including but not limited to: wires, optical cables, RF (Radio Frequency), etc., or any suitable combination of the above.

[0133] The computer-readable storage medium may be included in the stress testing device of the MTK platform; or may exist independently without being assembled into the stress testing device of the MTK platform.

[0134] The computer-readable storage medium carries one or more programs. When the one or more programs are executed by the stress test device of the MTK platform, the stress test device of the MTK platform: simulates manual operation based on the automated script, selects the firmware package and executes the upgrade process; creates a user input interface based on the tkinter library; obtains test parameters from the user input interface; and performs automated testing through the pyautogui library and the subprocess library based on the test parameters. The computer program code for performing the operation of the present application can be written in one or more programming languages ​​or a combination thereof, and the programming languages ​​include object-oriented programming languages ​​such as Java, Smalltalk, C++, and conventional procedural programming languages ​​such as "C" language or similar programming languages. The program code can be executed completely on the user's computer, partially on the user's computer, as an independent software package, partially on the user's computer and partially on a remote computer, or completely on a remote computer or server. In the case of a remote computer, the remote computer can be connected to the user's computer through any type of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or it can be connected to an external computer (for example, through the Internet using an Internet service provider).

[0135] The flow chart and block diagram in the accompanying drawings illustrate the possible architecture, function and operation of the system, method and computer program product according to various embodiments of the present application. In this regard, each square box in the flow chart or block diagram can represent a module, a program segment or a part of a code, and the module, the program segment or a part of the code contains one or more executable instructions for realizing the specified logical function. It should also be noted that in some alternative implementations, the functions marked in the square box can also occur in a sequence different from that marked in the accompanying drawings. For example, two square boxes represented in succession can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each square box in the block diagram and / or flow chart, and the combination of the square boxes in the block diagram and / or flow chart can be implemented with a dedicated hardware-based system that performs a specified function or operation, or can be implemented with a combination of dedicated hardware and computer instructions.

[0136] The modules involved in the embodiments described in this application may be implemented by software or hardware, wherein the name of the module does not constitute a limitation on the unit itself in some cases.

[0137] The readable storage medium provided by the present application is a computer-readable storage medium, which stores computer-readable program instructions (i.e., computer programs) for executing the stress testing method of the MTK platform described above, and can solve the technical problem of how to improve the efficiency and reliability of firmware upgrade stress testing. Compared with the prior art, the beneficial effects of the computer-readable storage medium provided by the present application are the same as the beneficial effects of the stress testing method of the MTK platform provided by the above embodiment, and will not be repeated here.

[0138] An embodiment of the present application provides a computer program product, including a computer program, which implements the steps of the stress testing method of the MTK platform as described above when executed by a processor.

[0139] The computer program product provided by the present application can solve the technical problem of how to improve the efficiency and reliability of firmware upgrade stress testing. Compared with the prior art, the beneficial effects of the computer program product provided by the embodiment of the present application are the same as the beneficial effects of the stress testing method of the MTK platform provided by the above embodiment, which will not be repeated here.

[0140] The above are only preferred embodiments of the present application, and are not intended to limit the patent scope of the present application. Any equivalent structure or equivalent process transformation made using the contents of the present application specification and drawings, or directly or indirectly applied in other related technical fields, are also included in the patent processing scope of the present application.

Claims

1. A stress testing method for an MTK platform, characterized in that: The method comprises: Simulate manual operations based on automated scripts to select firmware packages and execute upgrade processes; Create a user input interface based on the tkinter library; Acquire test parameters from the user input interface; Based on the test parameters, automated testing is performed using the pyautogui library and the subprocess library.

2. The method according to claim 1, characterized in that Before the step of simulating manual operation based on the automated script, selecting a firmware package and executing the upgrade process, the following steps are also included: Divide the automation script into modules according to the functions of the automation script; Based on the result of module division, the execution flow of the automation script is planned.

3. The method according to claim 2, characterized in that The automation script includes a firmware selection module, an upgrade execution module and a log recording module. The steps of simulating manual operations based on the automation script, selecting a firmware package and executing the upgrade process include: Based on the firmware selection module, simulate manual operation to select a firmware package; Based on the logging module, record the time and timestamp of the test process; Based on the upgrade execution module, a firmware upgrade process is executed.

4. The method according to claim 1, characterized in that The steps of creating a user input interface based on the tkinter library include: Import the tkinter library and initialize the main window; Determine the window layout according to the set layout data; Add labels and input boxes to the window after layout, and define functions to get parameters; Create a click button, and bind the click button to the function for obtaining parameters; Start the main event loop of the tkinter library to obtain the user input interface.

5. The method according to claim 1, characterized in that The step of obtaining test parameters from the user input interface includes: Acquire text data input by the user from the user input interface; Based on a preset format standard, the text data is formatted to obtain standard text data; Based on a preset data range, verifying the validity of the standard text data; The verified standard text data is used as the test parameter.

6. The method according to claim 1, characterized in that The step of performing automated testing based on the test parameters through the pyautogui library and the subprocess library includes: Perform firmware upgrade by simulating keyboard and mouse operations through the pyautogui library; The logs during the upgrade process are recorded based on the subprocess library.

7. A stress test device for an MTK platform, characterized in that: The device comprises: A simulation module is used to simulate manual operations based on automated scripts, select firmware packages, and execute the upgrade process; Input interface creation module, used to create user input interface based on tkinter library; A parameter acquisition module, used to acquire test parameters from the user input interface; The test module is used to perform automated testing based on the test parameters through the pyautogui library and the subprocess library.

8. A computer device, characterized in that: The device comprises: a memory, a processor, and a stress test program of the MTK platform stored in the memory and executable on the processor, wherein the stress test program of the MTK platform is configured to implement the steps of the stress test method of the MTK platform as described in any one of claims 1 to 6.

9. A storage medium, characterized in that: The storage medium stores a stress test program of the MTK platform, and when the stress test program of the MTK platform is executed by the processor, the steps of the stress test method of the MTK platform according to any one of claims 1 to 6 are implemented.

10. A computer program product, characterized in that The computer program product comprises a computer program, and when the computer program is executed by a processor, the steps of the stress testing method of the MTK platform according to any one of claims 1 to 6 are implemented.

Images