CN103064785B - A kind of detection method of terminal capabilities and device - Google Patents

Abstract

The invention discloses a terminal performance detection method and device, wherein the method specifically includes: creating a test information base class and a test execution base class; wherein, the test information base class is used to describe the information of a test case, and the test The execution base class is used to execute the test case; for the test case, the corresponding test case information class is derived from the test information base class, and the corresponding test case execution class is derived from the test execution base class; wherein, the The parameters passed by the test case information class in the constructor include the test case execution class name of the current test case; the test case information class is instantiated to obtain the corresponding test case object; for the test case object, according to its corresponding The name of the test case execution class obtains the corresponding test case execution class, and calls the obtained test case execution class to execute the corresponding test case. The invention can reduce the product development period and improve the product development efficiency.

Description

Method and device for detecting terminal performance

technical field

The invention relates to the technical field of testing, in particular to a method and device for detecting terminal performance.

Background technique

With the rise of the mobile Internet, mobile terminals such as smart phones have gradually become one of the indispensable tools in people's daily life. However, at present, the mobile terminals developed and produced by different manufacturers are different, so it is impossible to directly compare and analyze the different mobile terminals of different manufacturers, and it is impossible to evaluate and select the performance of different mobile terminals of different manufacturers. type.

In view of the above problems, some existing testing software can test the performance of mobile terminals more comprehensively, which is convenient for comparing and evaluating the performance of different mobile terminals from different manufacturers. At present, the performance of mobile terminals that can be tested can specifically include: CPU integer performance, CPU floating point performance, 2D (two-dimensional, TwoDimensions) drawing performance, 3D (three-dimensional, ThreeDimensions) drawing performance, database performance, SD card (secure digital card, SecureDigitalMemoryCard) speed and more.

Since one type of terminal performance usually corresponds to one test case, testing of terminal performance often requires testing of multiple test cases. Existing detection methods for terminal performance are usually to write corresponding code segments for a test case, wherein the code segments between test cases have a certain correlation (for example, the code segment of the next test case needs to depend on the execution result of the previous test case etc).

With the existing terminal performance detection method, if the test requirements change, many steps required for the detection process may need to be modified, which involves the overall code segment modification. For example, if you need to adjust the execution order of multiple test cases, you need to adjust the positions of multiple code segments of the associated test cases, which is more error-prone; for another example, if you need to add a new test case, you need to rewrite a complete test The code segment corresponding to the process, and a complete test process involves many operations, such as initialization, time control, interface control, evaluation algorithm, etc. In short, the existing terminal performance detection method has the problems of inflexibility and poor scalability, so if the existing terminal performance detection method is applied in the product development process, it is easy to increase the product development cycle and reduce the product development efficiency.

In short, a technical problem that needs to be solved urgently by those skilled in the art is: how to reduce the product development cycle and improve the product development efficiency.

Contents of the invention

In view of the above problems, the present invention is proposed to provide a terminal performance detection method and device that overcome the above problems or at least partially solve the above problems.

According to one aspect of the present invention, a method for detecting terminal performance is provided, including:

Create a test information base class and a test execution base class; wherein, the test information base class is used to describe the information of the test case, and the test execution base class is used to execute the test case;

For the test case, derive the corresponding test case information class from the test information base class, and derive the corresponding test case execution class from the test execution base class; wherein, the test case information class is in the constructor The passed parameters include the test case execution class name of the current test case;

Instantiate the test case information class to obtain a corresponding test case object;

For the test case object, obtain the corresponding test case execution class according to the corresponding test case execution class name, and call the obtained test case execution class to execute the corresponding test case.

Optionally, the method also includes:

The test case object obtained by instantiation is added to the list, and the initial execution mark of the test case object in the list is not executed;

Obtain the test case object whose execution flag is not executed from the list;

For the unexecuted test case object, obtain the corresponding test case execution class according to its associated test case execution class name, and call the obtained test case execution class to execute the corresponding test case; the execution of the completed test case object corresponds to The execution flag is executed.

Optionally, the test execution base class includes: a full-screen test base class for executing a full-screen test case and a non-full-screen test base class for performing a non-full-screen test case; wherein, the full-screen test base class consists of the Android system The Activity class is derived from;

Then the test case execution class includes: a full screen test case execution class derived from the full screen test base class and a non-full screen test case execution class derived from the non-full screen test base class.

The information of the test case includes a detection method whether the current test case is a full-screen test case;

Then the steps of calling the obtained test case execution class to execute the test of terminal performance include:

By calling the detection method of whether the current test case in the test case object is a full screen test case, detect whether the test case corresponding to the test case object is a full screen test case;

When the test case corresponding to the test case object is a full-screen test case, call the corresponding full-screen test case execution class to execute the corresponding test case;

When the test case corresponding to the test case object is a non-full-screen test case, the corresponding non-full-screen test case execution class is invoked to execute the corresponding test case.

Optionally, the step of calling the corresponding full-screen test case execution class to execute the terminal performance test includes:

Create and start an object of a full-screen test class from the current activity, execute the corresponding test case by the object of the full-screen test class, and return the corresponding test result to the current activity;

The current activity gets the test results returned by an object of this new fullscreen test class.

Optionally, the invocation of the corresponding non-full-screen test case execution class executes a test of terminal performance, including:

Instantiate the non-full-screen test case execution class to obtain a corresponding non-full-screen test case object;

Create a background test thread, and pass the non-full-screen test case object into the background test thread;

Start the background test thread to execute the corresponding test case.

Optionally, the member functions of the test execution base class include: a test process function for describing the test process; a test case execution class derived from the test execution base class covers the test process function to execute the corresponding test case testing process.

Optionally, the member functions of the test execution base class include one or more of the following test attribute functions: the first waiting function used to describe the time to wait before executing the current test case, used to describe the current test case The round number function of the number of execution rounds, and the second waiting function used to describe the time to wait before executing each round of the current test case;

The test case execution class derived from the test execution base class overrides the test attribute function to execute the test attribute of the corresponding test case.

According to another aspect of the present invention, a device for detecting terminal performance is provided, including:

The base class creation module is adapted to create a test information base class and a test execution base class; wherein, the test information base class is used to describe the information of the test case, and the test execution base class is used to execute the test case;

The derivation module is adapted to derive a corresponding test case information class from the test information base class for a test case, and derive a corresponding test case execution class from the test execution base class; wherein, the test case information The parameters passed by the class in the constructor include the test case execution class name of the current test case;

An instantiation module, adapted to instantiate the test case information class to obtain a corresponding test case object;

The object execution class acquisition module is suitable for obtaining the corresponding test case execution class according to the corresponding test case execution class name for the test case object; and

The object test case execution module is suitable for invoking the acquired test case execution class to execute corresponding test cases.

A terminal performance detection method and device of the present invention have the following beneficial effects:

The present invention obtains the test information base class used to describe the information of the test case and the test execution base class used to execute the test case according to the detection attribute abstraction of the terminal performance by adopting an object-oriented method; Any test case can be executed by using the derived class of the test information base class and the instantiated object of the derived class of the test execution base class, and the scheduling of multiple test cases only needs to schedule the derived class corresponding to the test information base class Therefore, if the test requirement changes with the solution of the present invention, only the corresponding instantiated object needs to be changed. For example, if it is necessary to adjust the execution order of multiple test cases, it is only necessary to adjust the execution order of the instantiated objects of the derived classes of the test information base class corresponding to the multiple test cases without adjusting the specific code segments. Can avoid the phenomenon that the code section goes wrong; Another example, if you need to add a new test case, you only need to use the derived class of the test information base class and the instantiated object of the derived class of the test execution base class for the new test case. Yes, without rewriting the code segment corresponding to a complete test process; in a word, the terminal performance test scheme of the present invention can flexibly carry out multiple test cases, and can easily adapt to any addition, deletion or order of test cases Adjustment, in a word, the present invention can improve the flexibility and expansibility of the terminal performance test.

Applying the detection method of the terminal performance of the present invention in the product development process can reduce the product development cycle and improve the product development efficiency.

The above description is only an overview of the technical solution of the present invention. In order to better understand the technical means of the present invention, it can be implemented according to the contents of the description, and in order to make the above and other purposes, features and advantages of the present invention more obvious and understandable , the specific embodiments of the present invention are enumerated below.

Description of drawings

Various other advantages and benefits will become apparent to those of ordinary skill in the art upon reading the following detailed description of the preferred embodiment. The drawings are only for the purpose of illustrating a preferred embodiment and are not to be considered as limiting the invention. Also throughout the drawings, the same reference numerals are used to designate the same components. In the attached picture:

FIG. 1 shows a flowchart of a method for detecting terminal performance according to an embodiment of the present invention;

FIG. 2 shows a flowchart of a method for detecting terminal performance according to an embodiment of the present invention;

FIG. 3 shows a flow chart of a method for detecting terminal performance according to an embodiment of the present invention;

FIG. 4 shows a structural diagram of an apparatus for detecting terminal performance according to an embodiment of the present invention;

FIG. 5 shows a flowchart of a method for displaying a terminal performance detection result according to an embodiment of the present invention;

FIG. 6 shows a schematic diagram of a method for presenting a terminal performance detection result according to an embodiment of the present invention;

FIG. 7 shows a schematic diagram of a display method of a terminal performance detection result according to an embodiment of the present invention; and

Fig. 8 shows a structural diagram of an apparatus for displaying a terminal performance detection result according to an embodiment of the present invention.

detailed description

Exemplary embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. Although exemplary embodiments of the present disclosure are shown in the drawings, it should be understood that the present disclosure may be embodied in various forms and should not be limited to the embodiments set forth herein. Rather, these embodiments are provided for more thorough understanding of the present disclosure and to fully convey the scope of the present disclosure to those skilled in the art.

Referring to FIG. 1 , it shows a flow chart of a method for detecting terminal performance according to an embodiment of the present invention, which may specifically include:

Step 101, create a test information base class and a test execution base class; wherein, the test information base class is used to describe the information of the test case, and the test execution base class is used to execute the test case;

Step 102, for the test case, derive the corresponding test case information class from the test information base class, and derive the corresponding test case execution class from the test execution base class; wherein, the test case information class is in The parameters passed in the constructor can specifically include the name of the test case execution class of the current test case;

Step 103, instantiate the test case information class to obtain a corresponding test case object;

Step 104, for the test case object, obtain the corresponding test case execution class according to the corresponding test case execution class name, and call the obtained test case execution class to execute the corresponding test case.

The embodiments of the present invention can be applied to the detection of the performance of mobile terminals such as smart phones, tablet computers, notebook computers, and PDAs (Personal Digital Assistants), and can also be applied to the detection of the performance of fixed terminals such as desktop computers. The terminal is not restricted.

Existing terminal performance testing methods adopt a process-oriented design. The process-oriented design here is to analyze the steps needed to solve the problem, and then use functions to implement these steps step by step. When using them, they can be called one by one. For the detection of terminal performance, such behavior is scattered in many steps in the process-oriented design, which is beneficial for designers to make various simplifications according to the actual situation, but it has the disadvantages of poor scalability and flexibility, specifically shown in : If the test requirements change, many steps required for the detection process may need to be changed, which involves the overall code segment changes, etc., and the overall code segment changes are likely to increase the product development cycle and reduce product quality. development efficiency.

However, the detection method of the terminal performance of the present invention adopts an object-oriented design. The object-oriented design here is to decompose the constituent problem affairs into each object. The purpose of establishing an object is not to complete a step, but to describe the overall Behavior in the steps to solve the problem. In the object-oriented design, the behavior of terminal performance detection can only appear in its instantiated object, so if the test requirements change, you only need to change the corresponding instantiated object, and the change is only partial.

In the specific implementation, the present invention obtains the test information base class used to describe the information of the test case and the test execution base class used to execute the test case according to the detection attribute abstraction of the terminal performance by adopting an object-oriented abstract method; thus, By adopting the object-oriented inheritance method, any test case can be executed by using the derived class of the test information base class and the instantiated object of the derived class of the test execution base class in conjunction with the test case.

Among them, for the abstracted test information base class, the information of the test case can be described by using member variables and member functions; for the abstracted test execution base class, the execution information of the test case can be described by using member variables and member functions , where the execution information of the test case may include a specific test process, for example, a complete test process may specifically include: initialization, time control, interface control, evaluation algorithm, release space, and so on.

In a preferred embodiment of the present invention, the member functions of the test execution base class may specifically include: a test process function used to describe the test process; a test case execution class derived from the test execution base class covers all Describe the test flow function to execute the test flow of the corresponding test case.

According to the inheritance mechanism, for the corresponding test case information class derived from the test information base class, it can automatically inherit the member variables and member functions of the test information base class, and it can also pass the corresponding test case through the constructor The parameters of the test case; here, the parameters of the test case may specifically include the name of the test case execution class of the current test case.

In addition, it can be understood that according to the inheritance mechanism, the test case information class and the test case execution class are used as subclasses. When deriving, the member functions of the parent class can be overwritten to realize the private information of the corresponding test case. For example, the test case execution class The evaluation process algorithm corresponding to the test case, etc. can be executed in the test process function.

Since the test case information class is derived from the test information base class, the test case execution class is derived from the test execution base class, so that the instantiated objects of the test case information class and the test case execution class are used in conjunction Any test case can be executed.

The present invention has the following advantages:

With the solution of the present invention, if the test requirement changes, only the corresponding instantiated object needs to be changed.

For example, if it is necessary to adjust the execution order of multiple test cases, it is only necessary to adjust the execution order of the instantiated objects of the derived classes of the test information base class corresponding to the multiple test cases without adjusting the specific code segments. It can avoid the phenomenon of code segment errors;

As another example, if you need to add a new test case, you only need to use the derived class of the test information base class and the instantiated object of the derived class of the test execution base class for the new test case, without rewriting a complete test The code segment corresponding to the process;

In a word, the test scheme of the terminal performance of the present invention can flexibly carry out multiple test cases, and can easily adapt to any addition, deletion or order adjustment of test cases. In a word, the present invention can improve the flexibility and expansion of the terminal performance test sex.

Referring to FIG. 2 , it shows a flow chart of a method for detecting terminal performance according to an embodiment of the present invention, which may specifically include:

Step 201, create a test information base class and a test execution base class; wherein, the test information base class is used to describe the information of the test case, and the test execution base class is used to execute the test case;

Step 202, for the test case, derive the corresponding test case information class from the test information base class, and derive the corresponding test case execution class from the test execution base class; wherein, the test case information class is in The parameters passed in the constructor can specifically include the name of the test case execution class of the current test case;

Step 203, instantiate the test case information class to obtain a corresponding test case object;

Step 204, adding the instantiated test case object to the list, and the initial execution flag of the test case object in the list is not executed;

Step 205, obtaining the test case object whose execution flag is not executed from the list;

Step 206, for the unexecuted test case object, obtain the corresponding test case execution class according to its associated test case execution class name, and call the obtained test case execution class to execute the corresponding test case; execute the completed test The execution flag corresponding to the use case object is executed.

In the embodiment of the present invention, all test case objects are added to the list. In the detection process of the terminal performance, it is only necessary to obtain the unexecuted test case objects one by one, and find the corresponding test case execution class for the obtained test case objects. The desired terminal performance detection result can be obtained by executing the corresponding test case. In a specific implementation, test case objects whose execution flags are not executed in the list may be obtained by traversing the list. Moreover, it can be understood that after executing a test case object, its execution flag can be modified to have been executed.

Referring to FIG. 3 , it shows a flow chart of a method for detecting terminal performance according to an embodiment of the present invention, which may specifically include:

Step 301, create a test information base class and a test execution base class; wherein, the test information base class is used to describe the information of the test case, and the test execution base class is used to execute the test case; the test execution base class can specifically be Including: a full-screen test base class for performing a full-screen test case and a non-full-screen test base class for performing a non-full-screen test case; wherein, the full-screen test base class is derived from the Activity class of the Android system; the test case The specific information can include the detection method of whether the current test case is a full-screen test case;

Step 302, for the test case, derive the corresponding test case information class from the test information base class, and derive the corresponding test case execution class from the test execution base class; wherein, the test case information class is in The parameters passed in the constructor can specifically include the test case execution class name of the current test case; the test case execution class can specifically include: the full screen test case execution class derived from the full screen test base class and the non- The non-full-screen test case execution class derived from the full-screen test base class;

Step 303, instantiate the test case information class to obtain the corresponding test case object;

Step 304, for the test case object, obtain the corresponding test case execution class according to its corresponding test case execution class name;

Step 305: Detect whether the test case corresponding to the test case object is a full-screen test case by invoking the detection method of whether the current test case in the test case object is a full-screen test case;

Step 306, when the test case corresponding to the test case object is a full-screen test case, call the corresponding full-screen test case execution class to execute the corresponding test case;

Step 307, when the test case corresponding to the test case object is a non-full screen test case, call the corresponding non-full screen test case execution class to execute the corresponding test case.

Most of the current mobile terminals use the Android operating system. Firstly, the principle of Activity in the Android operating system will be described. In the Android operating system, an Activity is an application component that can be used to provide a screen, and it can also be used to interact to complete a certain task, such as dialing, taking pictures, sending emails, viewing maps, etc.; usually, each Activity is given A window on which the user interface can be drawn. The window usually fills the screen, but it can also be smaller than the screen and float on top of other windows.

Currently, the performance of the mobile terminal that can be tested specifically may include: CPU integer performance, CPU floating-point performance, 2D drawing performance, 3D drawing performance, database performance, storage system, and the like. Among them, the tests of 2D drawing performance and 3D drawing performance belong to the full-screen test of the foreground. Full-screen tests and non-full-screen tests in the background do not need to be run in their own Activity.

Therefore, the embodiment of the present invention abstracts a full-screen test base class for executing full-screen test cases and a non-full-screen test base class for executing non-full-screen test cases according to the test attributes of terminal performance; It runs in its own Activity, so it needs to be derived from the Activity class of the Android system; in addition, for test cases, the corresponding full-screen test case execution class and non-full-screen test case can be dispatched from the full-screen test base class and non-full-screen test base class Execute the class, and call it to execute the corresponding test case.

It should be noted that since the test information base class can describe the information of the test case by using member variables and member functions, in practical applications, member functions can be used to describe the detection method of whether the current test case is a full-screen test case . For example, in an application example of the present invention, the member function publicBooleanisBackground() can be used to detect whether the current test case is a full-screen test case, if so, return false, indicating that it is a full-screen test case, otherwise return true, indicating that it is a non-full-screen test Example. In this way, step 305 can use the pointer of the test case object to call the member function and return the corresponding result.

In a preferred embodiment of the present invention, the step 306 of calling the corresponding full-screen test case execution class to execute the terminal performance test may specifically include:

Step S101, create and start an object of the full-screen test class from the current activity, execute the corresponding test case by the object of the full-screen test class, and return the corresponding test result to the current activity;

Step S102, the current activity obtains the test result returned by the object of the new full-screen test class.

Here, the current activity is used to indicate the caller of the full-screen test case execution class, and the current activity generally appears as the main window for displaying the test interface; during the calling process of the full-screen test case execution class, the current activity is mainly used to create And start an object of the full-screen test class to start the activity required by the full-screen test, and wait for the object of the full-screen test class to return the corresponding test result.

In a specific implementation, an object of a full-screen test class can be created and started from the current activity through startActivityForResult(Intentintent, intrequestCode). Among them, Intent is the intent class of Android, and intent is an object of the intent class, which is used to pass the parameters required to start an object of a full-screen test class, which specifies the class name of the object of the full-screen test class that needs to be started ( The class name is also the test case execution class name in step 304); the value of requestCode is self-defined and can be used to identify the object of the full-screen test class that needs to be started.

For the full-screen test class, because it derives from the full-screen test base class for the test case, it describes a specific test process; the object of the full-screen test class can be instantiated according to the full-screen test class, and it can be obtained according to the full-screen test class. Describe the test process and execute the corresponding test cases.

In a specific implementation, the object of the full-screen test class can save the test result through setResult(intresultCode, Intentdata), and return the saved test result by calling onActivityResult(intrequestCode, intresultCode, Intentdata) of the current activity. Among them, if the object of the full-screen test class may have several different test results returned, the resultCode parameter can be used to identify and distinguish, data is used to indicate the returned data, and onActivityResult(intrequestCode, intresultCode, Intentdata) is the callback function of the current activity.

Further, the current activity can obtain the test result returned by the object of the new full-screen test class according to the resultCode parameter and the data parameter.

In another preferred embodiment of the present invention, the step 307 of calling the corresponding non-full-screen test case execution class to execute the terminal performance test may specifically include:

Step S201, instantiate the non-full-screen test case execution class to obtain a corresponding non-full-screen test case object;

Step S202, creating a background test thread, and passing the non-full-screen test case object into the background test thread;

Step S203, start the background test thread to execute the corresponding test case.

Assuming that the name of the non-full-screen test case execution class is BackgroundTest, and the pointer of the current test case object is pointer, then step S201 can be realized by BackgroundTestertester=pointer.getBackgroundTester(intent), wherein the intent is responsible for the action of an operation in the application , Action related data, additional data for description;

Since the non-full-screen test is running in the background, in order not to affect the update of the foreground interface, a background test thread is needed to complete. In an application example of the present invention, step S202 can be realized by BackgroundTestThreadthread=newBackgroundTestThread(tester). Wherein, BackgroundTestThread is a thread class derived from the Thread class, and, in the process of instantiating the object thread of BackgroundTestThread, the non-full-screen test case object can be passed in the constructor of BackgroundTestThread, by the non-full-screen test case object Test in the run() method and notify the foreground interface; here, the run() method keeps the thread running in a loop until the condition is not met.

Step S203 can be realized by thread.start(). After executing thread.start(), thread will automatically execute the run() method; it can be understood that before executing thread.start(), thread.setPriority(Thread .MAX_PRIORITY) sets the priority of the thread to the maximum, making it execute first.

In the above method embodiments, the description of each method embodiment has its own emphases, and for the part not described in detail in a certain method embodiment, you can refer to the relevant descriptions of other method embodiments.

Moreover, those skilled in the art can readily imagine that any combination of the above method embodiments is feasible, but due to space limitations, this specification will not describe them in detail here.

Finally, it needs to be added that, in a preferred embodiment of the present invention, the member functions of the test execution base class may specifically include one or more of the following test attribute functions: The first waiting function of the time to wait is used to describe the round number function of the number of execution rounds of the current test case, and the second waiting function is used to describe the time to wait before executing each round of the current test case;

The test case execution class derived from the test execution base class overrides the test attribute function to execute the test attribute of the corresponding test case.

In practical applications, a test case may require multiple rounds of testing. Taking the test of CPU floating-point performance as an example, in order to make the test result more stable, it is necessary to perform several more rounds; that is, in the embodiment of the present invention, the number of execution rounds is aimed at the same test case; the second waiting function is The waiting time between each round of test cases;

In addition, due to the individuality of the test case, it may take a certain amount of time to do the preparatory work, such as the initialization and release of space in the test process are considered as the preparatory work. Therefore, in order to improve the stability of the test results, the first waiting function can be used to represent Waiting time between different test cases.

It can be understood that those skilled in the art can set the time values corresponding to the first waiting function and the second waiting time according to time requirements, which is not limited in the present invention.

In addition, in order to facilitate testers to monitor the test, in another preferred embodiment of the present invention, the information of the test case may also include description information of the current test case;

Then described method can also comprise:

Step S301, obtaining description information of a test case corresponding to the test case object;

Step S302, displaying the description information of the test case corresponding to the test case object on the test interface;

Step S303, updating the progress information on the test interface.

Assuming that the member function getTitle() of the test information base class is used to return the test case description, and assuming that the pointer of the current test case object is pointer, then step S301 can be realized through Stringtag=pointer.getTitle(), and step 302 can be realized through txtItem. setText(String.format(strProgressArg,tag,index,list.size())), step S303 can be realized through benchHandler.post(progressUpdater). in,

txtItem is a TextView control;

setText() is used to set the text to be displayed;

benchHandler is a message processing Handler, because UI controls cannot be updated in non-UI (user interface, UserInterface) threads, so they must be processed through messages;

post() is used to send a message;

progressUpdater is an UpdateProgressHandler, which is derived from Runnable and is another implementation of Java threads. post() requires a Runnable object as a parameter, and its specific function is to notify benchHandler to update the interface.

In this preferred embodiment, the test monitoring is realized by displaying the description information of the test case and the execution progress information of the test case on the test interface.

In order for those skilled in the art to better understand the present invention, an example of a terminal performance detection method according to an embodiment of the present invention is provided here, which may specifically include:

Step S401, create a test information base class and a test execution base class; wherein, the test information base class is used to describe the information of the test case, and the test execution base class is used to execute the test case; the test execution base class can specifically be Including: a full-screen test base class for performing a full-screen test case and a non-full-screen test base class for performing a non-full-screen test case; wherein, the full-screen test base class is derived from the Activity class of the Android system; the test case The specific information can include the detection method of whether the current test case is a full-screen test case;

Referring to Table 1, it shows an example of member variables of a test information base class Case according to an embodiment of the present invention.

Table 1

member variable name member variable type Member variable description tag String test case name package String Test case package name Background Tester Background Tester Object of BackgroundTester tester Tester Object of Tester mRepeatNow Integer Number of repeated tests intent intent Used to save the passed parameters context Context the context

Referring to Table 2, it shows an example of member functions of a test information base class Case according to an embodiment of the present invention.

Table 2

Referring to Table 3, it shows an example of member functions of a full-screen test base class and a non-full-screen test base class according to an embodiment of the present invention.

table 3

member function name member function name type Member function description getTag() String Set the evaluation use case Tag sleepBeforeStart() int first wait function sleepBetweenRound int second wait function oneRound() void Test process function

Step S402, for the test case, derive the corresponding test case information class from the test information base class, derive the corresponding full screen test case execution class from the full screen test base class, and derive from the full screen test base class Go out corresponding full-screen test case execution class; Wherein, the parameter that described test case information class transmits in the constructor can specifically include the test case execution class name of current test case;

The following takes the test cases of 2D performance and CPU integer as examples to illustrate the implementation process of deriving the corresponding test case information class from the test information base class:

Test information base class derivation 1,

Create a new Case2D class to describe the information of the 2D performance corresponding to the test case, which is derived from the test information base class Case.

Test information base class derivation 2,

Create a new CaseCPUInteger class to describe the information of the CPU integer performance corresponding to the test case. This class is derived from the test information base class Case.

Assuming that the full-screen test base class is Tester, the following uses the 2D performance corresponding test case as an example to illustrate the example of deriving the corresponding full-screen test case execution class OpenGLTest from the full-screen test base class. Since it is a full-screen test case, OpenGLTest derives from the Tester class Derived and implemented the corresponding interface of parent class Tester and grandparent class Activity:

Assuming that the non-full-screen test base class is BackgroundTester, the following takes the test case corresponding to the CPU integer performance as an example to illustrate an example of deriving the corresponding non-full-screen test case execution class TesterCPUInteger from the non-full-screen test base class:

Step S403, instantiate the test case information class to obtain a corresponding test case object;

Here, take the instantiation of the test case information class corresponding to 2D performance and CPU integer performance as an example for illustration:

Casegraphics2d = newCase2D(this);

Casecpuint=newCaseCPUInteger(this);

That is, graphics2d and cpuint are test case objects corresponding to 2D performance and CPU integer performance respectively.

Step S404, adding the instantiated test case object to the list, and the initial execution flag of the test case object in the list is not executed;

Step S405, obtaining test case objects whose execution flags are not executed from the list;

Step S406, for the unexecuted test case object, obtain the corresponding test case execution class according to the associated test case execution class name;

It should be noted that since the constructor of the class is called when the object is instantiated, taking the instantiation of Case2D as an example, its constructor is as follows:

Case2D(Context context){

super(context,"Case2D","OpenGLTest",1,1);

}

Among them, context, "Case2D", "OpenGLTest", 1, 1 are the parameters passed in the constructor, where "Case2D" is the name of the test case, and "OpenGLTest" is the name of the test case execution class, so you can get the corresponding The test case execution class.

Step S407, using the pointer of the unexecuted test case object to obtain the description information of the test case corresponding to the test case object, display the description information of the test case corresponding to the test case object on the test interface, and update Progress information on the test interface;

Step S408, using the pointer of the unexecuted test case object, calling the detection method of whether the current test case in the test case object is a full-screen test case, and detecting whether the test case corresponding to the unexecuted test case object is a full-screen test Example;

Step S409, when the test case corresponding to the unexecuted test case object is a full-screen test case, call the corresponding full-screen test case execution class to execute the corresponding test case;

Step S410, when the test case corresponding to the unexecuted test case object is a non-full-screen test case, call the corresponding non-full-screen test case execution class to execute the corresponding test case.

The relevant code examples of step S408-step S410 are as follows:

Referring to FIG. 4 , it shows a structural diagram of an apparatus for detecting terminal performance according to an embodiment of the present invention, which may specifically include:

The base class creation module 401 is adapted to create a test information base class and a test execution base class; wherein, the test information base class is used to describe the information of the test case, and the test execution base class is used to execute the test case;

The derivation module 402 is adapted to derive a corresponding test case information class from the test information base class for a test case, and derive a corresponding test case execution class from the test execution base class; wherein, the test case The parameters passed in the constructor of the information class include the test case execution class name of the current test case;

The instantiation module 403 is adapted to instantiate the test case information class to obtain a corresponding test case object;

The object execution class acquisition module 404 is adapted to obtain the corresponding test case execution class according to the corresponding test case execution class name for the test case object; and

The object test case execution module 405 is adapted to call the obtained test case execution class to execute the corresponding test case.

In a preferred embodiment of the present invention, the device may also include:

The object adding module is adapted to add the instantiated test case object to the list, and the initial execution flag of the test case object in the list is not executed;

An unexecuted object acquisition module, adapted to acquire the test case object whose execution flag is unexecuted from the list;

The unexecuted object execution module is suitable for obtaining the corresponding test case execution class according to the associated test case execution class name for the unexecuted test case object, and calling the obtained test case execution class to execute the corresponding test case .

In another preferred embodiment of the present invention, the test execution base class may specifically include: a full-screen test base class for executing a full-screen test case and a non-full-screen test base class for executing a non-full-screen test case; wherein, The full-screen test base class is derived from the Activity class of the Android system;

The test case execution class may specifically include: a full-screen test case execution class derived from the full-screen test base class and a non-full-screen test case execution class derived from the non-full-screen test base class.

The information of the test case can also include a detection method of whether the current test case is a full-screen test case;

Then the object test case execution module 405 may specifically include:

The full-screen detection submodule is adapted to detect whether the test case corresponding to the test case object is a full-screen test case by calling a detection method whether the current test case in the test case object is a full-screen test case;

The full-screen call submodule is suitable for calling the corresponding full-screen test case execution class to execute the corresponding test case when the test case corresponding to the test case object is a full-screen test case;

The non-full-screen calling submodule is suitable for invoking the corresponding non-full-screen test case execution class to execute the corresponding test case when the test case corresponding to the test case object is a non-full-screen test case.

In yet another preferred embodiment of the present invention, the full-screen calling submodule may specifically include:

The object creation unit is adapted to create and start an object of a full-screen test class from the current activity, execute corresponding test cases by the object of the full-screen test class, and return corresponding test results to the current activity; and

The result acquisition unit is suitable for the current activity to acquire the test result returned by the object of the new full-screen test class.

In a preferred embodiment of the present invention, the non-full screen calling submodule may specifically include:

A non-full-screen instantiation unit, adapted to instantiate the non-full-screen test case execution class to obtain a corresponding non-full-screen test case object;

A thread creation transfer unit is adapted to create a background test thread, and transfer the non-full-screen test case object into the background test thread; and

The thread starting unit is suitable for starting the background test thread to execute corresponding test cases.

In another preferred embodiment of the present invention, the member functions of the test execution base class may specifically include: a test process function used to describe the test process; a test case execution class derived from the test execution base class to cover The test process function is used to execute the test process of the corresponding test case.

In yet another preferred embodiment of the present invention, the member functions of the test execution base class may specifically include one or more of the following test attribute functions: the first parameter used to describe the waiting time before executing the current test case A waiting function, which is used to describe the number of rounds function of the number of execution rounds of the current test case, and the second waiting function used to describe the time to wait before executing each round of the current test case;

Then in a specific implementation, the test case execution class derived from the test execution base class may override the test attribute function to execute the test attribute of the corresponding test case.

Referring to FIG. 5 , it shows a flow chart of a method for displaying a terminal performance detection result according to an embodiment of the present invention, which may specifically include:

Step 501, create a test information base class and a test execution base class; wherein, the test information base class is used to describe the information of the test case, and the test execution base class is used to execute the test case;

Step 502, for the test case, derive the corresponding test case information class from the test information base class, and derive the corresponding test case execution class from the test execution base class; wherein, the test case information class is in The parameters passed in the constructor include the test case execution class name of the current test case;

Step 503, instantiate the test case information class to obtain the corresponding test case object;

Step 504, for the test case object, obtain the corresponding test case execution class according to its corresponding test case execution class name, and call the obtained test case execution class to execute the corresponding test case, and obtain the corresponding terminal performance detection result;

Step 505: Present the terminal performance detection result according to the request triggered by the terminal performance detection result on the user interface.

In an application example of the present invention, according to the trigger request of the terminal performance detection result on the user interface, the terminal performance detection result can be displayed on the UI of the current terminal for the user to view; The terminal performance detection result of the current terminal can know the performance of the current terminal, for example, the terminal performance detection result of the current terminal can be used as one of the factors for the user to purchase the current terminal, or the terminal performance detection results of multiple terminals can be As one of the comparison factors for the performance of multiple terminals. In a word, the present invention can display and feed back a relatively real terminal performance detection result to the user by displaying the terminal performance detection result.

It should be noted that the request triggered by the terminal performance detection result on the user interface may be generated through user operations such as mouse, keyboard, and touch gestures, and the user operation may specifically be obtained for an interface element with a trigger function such as a button on the user interface.

Referring to FIG. 6 , it shows a schematic diagram of a method for displaying terminal performance test results according to an embodiment of the present invention, wherein the user can send a request for database performance test trigger through the "Start Scoring" button on the interface, then the present invention implements The terminal performance detection involved in steps 601-604 may be performed according to the request, and at the same time, the detection progress of the terminal performance is displayed on the interface, 87% of which is an example of the detection progress. After the request is sent, the "start scoring" button on the interface becomes a "stop scoring" button. It can be understood that the user can stop the current database performance detection by clicking the "stop scoring" button. In addition, after the detection progress reaches 100%, the present invention can automatically display the corresponding terminal performance detection result, or, the present invention can trigger a request based on the terminal performance detection result on the user interface (such as clicking the button other than "start scoring" or " button other than the "Stop Scoring" button) to display the corresponding terminal performance testing results. For example, after the testing progress reaches 100%, the "Stop Scoring" button on the interface changes to the "View Scoring" button. It is understandable that the user can pass Click the "View Score" button to trigger the display of the terminal performance test results.

It can be understood that the terminal performance detection result may display the detection result of a certain terminal performance alone, or may display the detection results of multiple terminal performances; The detection results of multiple terminal performances; in short, the present invention does not limit the specific presentation manner.

Referring to FIG. 7 , it shows a schematic diagram of a display method of a terminal performance detection result according to an embodiment of the present invention, which displays the detection result of the terminal performance in the form of scores, and the displayed terminal performance may specifically include: CPU integer performance, CPU floating-point performance, 2D drawing performance, 3D drawing performance, database IO (input/output) performance, SD card writing speed, SD card reading speed and other performance scores, as well as the total score of terminal performance (overall performance score).

In some embodiments of the present invention, the detection client can report the terminal performance detection results of the current terminal to the detection server, and the detection server can also send the terminal performance detection results of various terminal samples to the detection client, by The detection client is presented to the user, so that the user can know the ranking of the terminal performance detection results of the current mobile terminal among various terminal samples, and the like.

It can be understood that those skilled in the art may display the terminal performance detection result at various locations in various display manners, and the embodiment of the present invention does not limit the display location and specific display manner of the terminal performance detection result.

Referring to FIG. 8 , it shows a structural diagram of an apparatus for displaying a detection result of terminal performance according to an embodiment of the present invention, which may specifically include:

The base class creation module 801 is adapted to create a test information base class and a test execution base class; wherein, the test information base class is used to describe the information of the test case, and the test execution base class is used to execute the test case;

The derivation module 802 is adapted to derive a corresponding test case information class from the test information base class for a test case, and derive a corresponding test case execution class from the test execution base class; wherein, the test case The parameters passed in the constructor of the information class include the test case execution class name of the current test case;

The instantiation module 803 is adapted to instantiate the test case information class to obtain a corresponding test case object;

The object execution class acquisition module 804 is adapted to obtain the corresponding test case execution class according to the corresponding test case execution class name for the test case object;

The object test case execution module 805 is suitable for invoking the obtained test case execution class to execute the corresponding test case; and

The result display module 806 is configured to display the terminal performance detection result according to a request triggered by the terminal performance detection result on the user interface.

In a specific implementation, the base class creation module 801, the derivation module 802, the instantiation module 803, the object execution class acquisition module 804 and the object test case execution module 805 can be located in various computer systems or server ends, and these three modules cooperate to complete the database Performance detection; the result display module 806 can be located in various displays for displaying the performance detection results of the database; wherein, the computer system or display can be located on mobile terminals such as smart phones, tablet computers, notebook computers, and PDAs , and can also be located on a fixed terminal such as a desktop computer.

The algorithms and displays presented herein are not inherently related to any particular computer, virtual system, or other device. Various generic systems can also be used with the teachings based on this. The structure required to construct such a system is apparent from the above description. Furthermore, the present invention is not specific to any particular programming language. It should be understood that various programming languages can be used to implement the content of the present invention described herein, and the above description of specific languages is for disclosing the best mode of the present invention.

In the description provided herein, numerous specific details are set forth. However, it is understood that embodiments of the invention may be practiced without these specific details. In some instances, well-known methods, structures and techniques have not been shown in detail in order not to obscure the understanding of this description.

Similarly, it should be appreciated that in the foregoing description of exemplary embodiments of the invention, in order to streamline this disclosure and to facilitate an understanding of one or more of the various inventive aspects, various features of the invention are sometimes grouped together in a single embodiment, figure, or its description. This method of disclosure, however, is not to be interpreted as reflecting an intention that the claimed invention requires more features than are expressly recited in each claim. Rather, as the following claims reflect, inventive aspects lie in less than all features of a single foregoing disclosed embodiment. Thus, the claims following the Detailed Description are hereby expressly incorporated into this Detailed Description, with each claim standing on its own as a separate embodiment of this invention.

Those skilled in the art can understand that the modules in the device in the embodiment can be adaptively changed and arranged in one or more devices different from the embodiment. Modules or units or components in the embodiments may be combined into one module or unit or component, and furthermore may be divided into a plurality of sub-modules or sub-units or sub-assemblies. All features disclosed in this specification (including accompanying claims, abstract and drawings), as well as any method or method so disclosed, may be used in any combination, except that at least some of such features and/or processes or units are mutually exclusive. All processes or units of equipment are combined. Each feature disclosed in this specification (including accompanying claims, abstract and drawings) may be replaced by alternative features serving the same, equivalent or similar purpose, unless expressly stated otherwise.

Furthermore, those skilled in the art will understand that although some embodiments described herein include some features included in other embodiments but not others, combinations of features from different embodiments are meant to be within the scope of the invention. and form different embodiments. For example, in the following claims, any of the claimed embodiments may be used in any combination.

The various component embodiments of the present invention may be implemented in hardware, or in software modules running on one or more processors, or in a combination thereof. Those skilled in the art should understand that a microprocessor or a digital signal processor (DSP) may be used in practice to implement some or all functions of some or all components in the device according to the embodiments of the present invention. The present invention can also be implemented as an apparatus or an apparatus program (for example, a computer program and a computer program product) for performing a part or all of the methods described herein. Such a program for realizing the present invention may be stored on a computer-readable medium, or may be in the form of one or more signals. Such a signal may be downloaded from an Internet site, or provided on a carrier signal, or provided in any other form.

It should be noted that the above-mentioned embodiments illustrate rather than limit the invention, and that those skilled in the art will be able to design alternative embodiments without departing from the scope of the appended claims. In the claims, any reference signs placed between parentheses shall not be construed as limiting the claim. The word "comprising" does not exclude the presence of elements or steps not listed in a claim. The word "a" or "an" preceding an element does not exclude the presence of a plurality of such elements. The invention can be implemented by means of hardware comprising several distinct elements, and by means of a suitably programmed computer. In a unit claim enumerating several means, several of these means can be embodied by one and the same item of hardware. The use of the words first, second, and third, etc. does not indicate any order. These words can be interpreted as names.

Claims (12)

1. A method for detecting terminal performance is characterized by comprising the following steps:

creating a test information base class and a test execution base class; the test information base class is used for describing information of a test case, and the test execution base class is used for executing the test case;

for the test case, deriving a corresponding test case information class from the test information base class, and deriving a corresponding test case execution class from the test execution base class; the parameters of the test case information class transferred in the constructor comprise the name of the test case execution class of the current test case;

instantiating the test case information class to obtain a corresponding test case object;

aiming at the test case object, acquiring a corresponding test case execution class according to a corresponding test case execution class name, and calling the acquired test case execution class to execute a corresponding test case;

wherein the test execution base class includes: the full screen test base class is used for executing a full screen test case and the non-full screen test base class is used for executing a non-full screen test case; the full screen testing base class is derived from an Activity Activity class of an Android system;

the test case execution class includes: a full screen test case execution class derived from the full screen test base class and a non-full screen test case execution class derived from the non-full screen test base class;

the information of the test case comprises a detection method for detecting whether the current test case is a full-screen test case;

the step of calling the obtained test case execution class to execute the corresponding test case includes:

detecting whether the test case corresponding to the test case object is a full-screen test case or not by calling a detection method for judging whether the current test case in the test case object is a full-screen test case or not;

when the test case corresponding to the test case object is a full-screen test case, calling a corresponding full-screen test case execution class to execute the corresponding test case;

and when the test case corresponding to the test case object is a non-full-screen test case, calling the corresponding non-full-screen test case execution class to execute the corresponding test case.

2. The method of claim 1, further comprising:

adding the test case object obtained by instantiation to a list, wherein the initial execution mark of the test case object in the list is unexecuted;

acquiring the test case object with the execution mark as unexecuted from the list;

aiming at the unexecuted test case object, acquiring a corresponding test case execution class according to the test case execution class name associated with the unexecuted test case object, and calling the acquired test case execution class to execute a corresponding test case; and the execution mark corresponding to the test case object after execution is executed.

3. The method of claim 1, wherein the step of invoking the corresponding full-screen test case execution class to execute the corresponding test case comprises:

creating and starting a full screen test class object from the current activity, executing a corresponding test case by the full screen test class object, and returning a corresponding test result to the current activity;

and acquiring the test result returned by the object of the full screen test class in the current activity.

4. The method of claim 1, wherein the step of invoking the corresponding non-full screen test case execution class to execute the corresponding test case comprises:

instantiating the non-full screen test case execution class to obtain a corresponding non-full screen test case object;

creating a background testing thread, and transmitting the non-full screen test case object to the background testing thread;

and starting the background testing thread to execute the corresponding testing case.

5. The method of claim 1, wherein testing member functions of an execution base class comprises: a test flow function for describing a test flow; and the test case execution class derived from the test execution base class covers the test flow function to execute the test flow of the corresponding test case.

6. The method of claim 1, wherein the member functions of the test execution base class include one or more of the following test attribute functions: the test system comprises a first waiting function, a round number function and a second waiting function, wherein the first waiting function is used for describing the waiting time required before the current test case is executed;

and the test case execution class derived from the test execution base class covers the test attribute function to execute the test attribute of the corresponding test case.

7. An apparatus for detecting terminal performance, comprising:

the base class creating module is suitable for creating a test information base class and a test execution base class; the test information base class is used for describing information of a test case, and the test execution base class is used for executing the test case;

the derivation module is suitable for deriving a corresponding test case information class from the test information base class and deriving a corresponding test case execution class from the test execution base class aiming at the test case; the parameters of the test case information class transferred in the constructor comprise the name of the test case execution class of the current test case;

the instantiation module is suitable for instantiating the test case information class to obtain a corresponding test case object;

the object execution class acquisition module is suitable for acquiring a corresponding test case execution class according to a corresponding test case execution class name of the test case object; and

the object test case execution module is suitable for calling the obtained test case execution class to execute the corresponding test case;

wherein the test execution base class includes: the full screen test base class is used for executing a full screen test case and the non-full screen test base class is used for executing a non-full screen test case; the full screen testing base class is derived from an Activity Activity class of an Android system;

the test case execution class includes: a full screen test case execution class derived from the full screen test base class and a non-full screen test case execution class derived from the non-full screen test base class;

the information of the test case also comprises a detection method for detecting whether the current test case is a full-screen test case;

the object test case execution module includes:

the full-screen detection sub-module is suitable for detecting whether the test case corresponding to the test case object is a full-screen test case or not by calling a detection method for judging whether the current test case in the test case object is a full-screen test case or not;

the full screen calling sub-module is suitable for calling the corresponding full screen test case execution class to execute the corresponding test case when the test case corresponding to the test case object is the full screen test case;

and the non-full screen calling sub-module is suitable for calling the corresponding non-full screen test case execution class to execute the corresponding test case when the test case corresponding to the test case object is a non-full screen test case.

8. The apparatus of claim 7, further comprising:

the object adding module is suitable for adding the test case object obtained by instantiation to a list, and the initial execution mark of the test case object in the list is not executed;

the unexecuted object acquisition module is suitable for acquiring the test case object with the unexecuted execution mark from the list;

the unexecuted object execution module is suitable for acquiring a corresponding test case execution class according to the test case execution class name associated with the unexecuted test case object and calling the acquired test case execution class to execute a corresponding test case; and the execution mark corresponding to the test case object after execution is executed.

9. The apparatus of claim 7, wherein the full screen invocation sub-module comprises:

the object creating unit is suitable for creating and starting an object of a full screen test class from the current activity, executing a corresponding test case by the object of the full screen test class and returning a corresponding test result to the current activity;

and the result acquisition unit is suitable for acquiring the test result returned by the object of the full screen test class in the current activity.

10. The apparatus of claim 7, wherein the non-full screen invocation sub-module comprises:

the non-full screen instantiation unit is suitable for instantiating the non-full screen test case execution class to obtain a corresponding non-full screen test case object;

the thread creating and transmitting unit is suitable for creating a background testing thread and transmitting the non-full screen test case object to the background testing thread;

and the thread starting unit is suitable for starting the background testing thread to execute the corresponding test case.

11. The apparatus of claim 7, wherein testing member functions of the execution base class comprises: a test flow function for describing a test flow; and the test case execution class derived from the test execution base class covers the test flow function to execute the test flow of the corresponding test case.

12. The apparatus of claim 7, wherein the member functions of the test execution base class comprise one or more of the following test attribute functions: the test system comprises a first waiting function, a round number function and a second waiting function, wherein the first waiting function is used for describing the waiting time required before the current test case is executed;

and the test case execution class derived from the test execution base class covers the test attribute function to execute the test attribute of the corresponding test case.