Detailed Description
In order to make the technical solutions in the present specification better understood by those skilled in the art, the technical solutions in the embodiments of the present specification will be clearly and completely described below with reference to the drawings in the embodiments of the present specification, and it is obvious that the described embodiments are only some embodiments of the present application, not all embodiments. All other embodiments, which can be made by one of ordinary skill in the art based on the embodiments herein without making any inventive effort, shall fall within the scope of the present application.
In the prior art, if a web page or an application program or an interface needs to be tested, a developer needs to write and run test codes by himself so as to execute a test process. If there is a new test requirement, such as testing a new web page or application or interface, then the test code needs to be rewritten or the existing test code needs to be modified substantially to accommodate the new test requirement. Therefore, under the existing test scheme, the code writing task of the developer is heavy, the code maintenance cost is high, and the developer is required to master and learn the corresponding code development language, so that the test efficiency is low.
The first embodiment (hereinafter referred to as "embodiment one") of the present disclosure provides a test method, where the execution subject of the embodiment one may be a terminal (including but not limited to a mobile phone, a computer, a pad, a television) or a server or an operating system or a test platform or a test system or an application program, that is, the execution subject may be various, and may be set, used, or changed according to needs. In addition, a third party application may also be provided to assist the executing entity in executing embodiment one. For example, as shown in fig. 1, the test method in the first embodiment may be performed by a server, and an application program (corresponding to the server) may be installed on a terminal (held by a user), and data transmission may be performed between the terminal or the application program and the server, and data collection or input or output or page or information processing may be performed by the terminal or the application program, so as to assist the server in performing the test method in the first embodiment.
As shown in fig. 2, the test method provided in the first embodiment includes:
S101, after the test condition of an execution main body is triggered, a test task configuration page is displayed, or after the test condition is triggered, a test request is sent to a test server, test basic configuration data sent by the test server is obtained, and a test task configuration page is generated and displayed according to the test basic configuration data, wherein the test task configuration page is used for configuring a test task;
In the first embodiment, the execution body may preset the test condition. The user's operation may trigger the test condition, for example, the user clicking on a button of the execution subject or an application installed on the execution subject may trigger the test condition, or the user may trigger the test condition by voice, or the user operates another device capable of data transmission with the execution subject. Examples a pair of how to trigger the test conditions is not limited. In general, test condition triggering means a test requirement of a user.
After the test condition is triggered, the execution subject (or other device capable of data transmission with the execution subject) may display a test task configuration page. How to display the test task configuration page may be as described in 1.1 and/or 1.2 (embodiments one is not limited to 1.1 and/or 1.2):
1.1, the execution main body can call the corresponding data stored by the execution main body and analyze and generate a test task configuration page.
1.2, After the test condition is triggered, the execution body may also send a test request to a test server (i.e., a server for executing a test task). After the test server obtains the test request sent by the execution subject (the execution subject sending the test request may be referred to as a test requester), the test server sends test basic configuration data to the execution subject. After the execution main body obtains the test basic configuration data sent by the test server, a test task configuration page is generated and displayed according to the test basic configuration data. Specifically, the execution body may parse the test basic configuration data and generate a test task configuration page.
If the test task configuration page is displayed by other devices, the display principle is the same as that of the execution main body.
It should be noted that the test task configuration page is used for (a user) configuring a test task. The test task configuration page may have corresponding buttons or options or input boxes, etc., so that the user configures the test task by selecting or inputting (there may be corresponding options or input boxes for selecting or inputting, the same applies below), etc. The test task configuration page in the first embodiment does not refer to a certain page, but may refer to one or more pages. If the test task configuration page has multiple pages, the multiple pages may include a test task configuration home page and/or a lower page of the test task configuration home page and/or a page to which the test task configuration home page is jumped one or more times for configuring the test task. In summary, all the pages for configuring the test tasks described in the first embodiment can be the test task configuration pages, regardless of the association relationship between these pages.
For the first embodiment, a test platform (the device may be the execution body described above, or may be a device other than the execution body described above, hereinafter referred to as a platform building device) may be built or arranged in advance by using various devices including a computer, and the test platform may be in the form of an application program or a model, and is used to perform a test task. The following describes how to build a test platform by taking a computer as a platform building device as an example:
In a first embodiment, various available computer languages may be downloaded as test platform development languages, described below as python language.
Python can be used as a test platform development language and a pycharm editor can be downloaded for writing python scripts.
The configuration pycharm editor, download framework packages, such as python Django-3.1.3 framework packages, frameworks for test platforms and related configurations may be implemented by the framework packages described above. Some specific configurations are described below (by way of example only, and the embodiment one is not limited to the following configurations):
arow= = 0.17.0, time module processing, may format time in python language.
Asgiref = 3.3.1 for wrapping or decorating asynchronous or synchronous functions, asynchronous functions may be called from synchronous threads and vice versa).
Beautifulsoup4 = = 4.9.3,Beautiful Soup is a Python library that can extract data from HTML or XML files.
Bs 4= 0.0.1 for providing python-like functions for handling navigation, searching, modifying analysis trees, etc.
Certifi = 2020.12.5 for verifying the trustworthiness of SSL certificates, while verifying the identity of the TLS host.
Chardet = 4.0.0, universal character encoding detector.
Ddt = 1.4.1 for adding libraries of test cases.
Django = 3.1.3, django is a high level PythonWeb framework.
Django-tors-headers = 3.5.0 for adding a cross-source resource sharing (CORS) header to the response, allowing intra-browser requests to Django applications from other sources.
Future= = 0.18.2 to allow support of Python 2 and Python3 using Python3.X compatible codebooks.
Idna = 2.10 for supporting internationalized domain name (IdNA) protocols in applications.
PyMySQL = 1.0.2, most public APIs are compatible with mysqlclient and MySQLdb.
Pyperclip = 1.8.1, support cross-platform clipboard utility for binary and text data.
Python-dateutil = 2.8.1, a date and time module, can be used in Python.
Pytz = 2020.4 pytz introduced the Olsontz database into Python. This library allows accurate cross-platform time zone calculations using Python2.4 or higher versions, and also solves the problem of ambiguous times at the end of the summer system.
Requests= = 2.25.1 for sending HTTP/1.1 requests, without manually adding a query string to the URL, nor formatting POST data.
Selenium= = 3.141.0 for Python language binding of Selenium WebDriver for automating interaction of Web browser with Python.
Serializers = 0.2.4 because each language has its own data type, different languages must specify a data type common to the various languages, such as json, xml, etc.
The serializer allows complex data such as query sets and model instances to be converted to native Python types that can be rendered into JSON, XML, or other content types.
Six= = 1.15.0, a Python 2 and 3 compatible library. It provides a utility function to smooth out differences between the Python versions in order to write Python code that is compatible on both Python versions.
Soupsieve = 2.1, which is intended to provide selection, matching and filtering using modern CSS selectors.
Sqlparse = 0.4.1, sqlparse is a non-validated SQL parser for Python that provides support for parsing, splitting and formatting of SQL statements.
Urllib 3= 1.26.2, http client of Python for Python ecosystem.
Mlrunner = 1.7.7 for generating XML reports, XML reports may be integrated with jenkins, or may be used to count case pass rate.
Through the above framework and the configuration including the above examples, and after configuring the local database MySQL, the test platform described in the first embodiment may be built. Of course, other development languages can be selected to build the test platform, and the corresponding framework and configuration are determined according to actual situations and requirements.
The test platform may be installed on the execution body in the form of an application program, and may also be arranged on a test server. The test condition triggering may include clicking or starting the test platform, and the test task configuration page may be a page of a test platform application program on the execution body.
In embodiment one, the test tasks include, but are not limited to, web page test tasks and/or application program test tasks and/or interface test tasks, and how the test tasks are configured may be in the manner described in 2.1 and/or 2.2 and/or 2.3 (in embodiment one, but not limited to, the manner described in 2.1 and/or 2.2 and/or 2.3):
2.1, webpage test task
The web page test task is a test task taking a (web side) web page as a test object. For web page test tasks, configuring test tasks may include:
2.1.1, determining a webpage to be tested;
The web address and/or URL and/or keyword of the web page can be input or selected in the test task configuration page, the execution body determines the web page to be tested according to the web address and/or URL and/or keyword, and the web page corresponding to the web address and/or URL and/or keyword is used as the web page to be tested.
For example, enter "XX search front", then the executing subject takes the XX search (XX search may be a search engine) front as the web page to be tested.
2.1.3, Positioning page elements to be tested of the webpage to be tested;
position information can be input or selected in the test task configuration page, so that an execution body can position page elements to be tested on the webpage to be tested according to the position information. For example, the coordinates of the page element to be tested on the webpage to be tested may be selected or input, or the coordinates of the page element to be tested on the screen of the (execution subject) may be selected or input when the page to be tested is displayed on the screen of the (execution subject), so that the execution subject locates the page element to be tested on the webpage to be tested according to any one or more of the coordinates.
The page elements herein include, but are not limited to, one or more of text, images, hyperlinks, navigation bars, animations, forms, frames, forms, banner advertisements, subtitles, hover buttons, daily stamps, calculators, audio, video, java applets on the page.
Along the above example, if the XX search home page is taken as the web page to be tested, and a button is provided on the home page, the coordinate of the button on the home page can be selected or input, or when the home page is selected or input and displayed on the screen, the coordinate of the button on the screen can be selected or input, so that the execution body locates the button according to the one or more coordinates as the page element to be tested on the home page. For another example, if there is a certain input box on the home page, the coordinates of the input box on the home page may be selected or input, or when the home page is selected or input and displayed on the screen, the coordinates of the input box on the screen may be selected or input, so that the execution body locates the input box according to the one or more coordinates, as the page element to be tested on the home page.
2.1.5, Creating a test task for the page element to be tested.
After determining the page element to be tested, a test task corresponding to the page element to be tested can be selected or input, so that the execution body creates the test task for the page element to be tested. The test task for the page element to be tested includes, but is not limited to, clicking and/or inputting the page element to be tested, i.e. clicking the page element to be tested and/or inputting using the page element to be tested.
Along the above example, a test task for the button, such as a click task, may be created assuming that the execution subject positioning button is the page element to be tested on the home page, and a test task, such as an input task, may be created for the input box assuming that the execution subject positioning input box is the page element to be tested on the home page.
2.2 Mobile end test task
The mobile terminal test task is a test task taking an application program installed by the terminal as a test object. For a mobile end test task, configuring the test task may include:
2.2.2, determining an application program to be tested;
Keywords of the application to be tested may be input in the test task configuration page to determine the application to be tested, or the application to be tested may be selected from the installed applications.
For example, entering a "search", the installed search application is taken as the application to be tested, or the search application is selected directly from the installed applications as the application to be tested.
2.2.4, Positioning a page to be tested of the application program to be tested and page elements to be tested of the page to be tested, and creating a test task aiming at the page elements to be tested, or creating a test task aiming at the application program to be tested.
The following is a description of the case:
2.2.4.2, a page to be tested of the application to be tested may be located. Specifically, a link and/or a keyword of a page to be tested may be input or selected in a test task configuration page, and the execution body determines a webpage to be tested of the application program according to the link and/or the keyword, including taking a webpage corresponding to the link and/or the keyword as the webpage to be tested. E.g., enter "home page", the executing body takes the application to be tested home page as the web page to be tested.
And determining page elements to be tested of the page to be tested. Position information can be input or selected in the test task configuration page, so that an execution body can position page elements to be tested on the webpage to be tested according to the position information. For example, the coordinates of the page element to be tested on the webpage to be tested may be selected or input, or the coordinates of the page element to be tested on the screen of the (execution subject) may be selected or input when the page to be tested is displayed on the screen of the (execution subject), so that the execution subject locates the page element to be tested on the webpage to be tested according to any one or more of the coordinates. The page elements herein may refer to examples of web page testing tasks.
And creating a test task for the page element to be tested. After determining the page element to be tested, a test task corresponding to the page element to be tested can be selected or input, so that the execution body creates the test task for the page element to be tested. The test task for the page element to be tested includes, but is not limited to, clicking and/or inputting the page element to be tested, i.e. clicking the page element to be tested and/or inputting using the page element to be tested.
The specific operation of the above description can refer to the description of the web page test task.
2.2.4.4, Creating a test task for the application to be tested. The test tasks directly aiming at the application to be tested can be input or selected in a test task configuration page, so that the test tasks directly aiming at the application to be tested are created, for example, clicking or double clicking or deleting the application to be tested.
2.3 Interface test tasks
The interface test task is a test task taking the interface as a test object. For interface test tasks, configuring test tasks may include:
2.3.1, determining a to-be-tested interface and a testing environment of the to-be-tested interface;
The interface may be entered or selected at a test task configuration page to execute the subject determination of the interface to be tested. The test environment of the interface to be tested can be input or selected in the test task configuration page, so that the execution body determines the test environment of the interface to be tested.
2.3.3, Creating a test task for the interface to be tested.
After the interface to be tested is determined, a test task corresponding to the interface to be tested can be selected or input, so that the execution main body creates the test task aiming at the interface to be tested. The test task for the interface to be tested includes, but is not limited to, executing one or more methods of get, post, delete, put on the interface to be tested.
The test task configuration can be saved, can be stored by the execution body, and can also be sent to a test server for storage. After each test condition is triggered, the test task configuration page may display the configured or saved test tasks for the user to perform operations, such as deletion or editing operations, on the configured or saved test tasks.
The foregoing illustrates that there may be a case as described in 1.2, and if the case is described in 1.2, after the test condition triggers (e.g., the user clicks on the test platform application), the executing entity (or the test platform application on the executing entity) may send a test request to the test server. After the test server obtains the test request sent by the execution body, the test server sends test basic configuration data to the execution body. Here, the test base configuration data. Since the user may start the test platform application program to configure the test task multiple times, after each test condition is triggered, the test basic configuration data may include not only some initial data (the initial data is used for displaying the test task configuration page in one or more initial states) but also data (if any) of the configured test task (before the test condition is triggered), so that the test task configuration page may display the previously configured test task for the user to perform operations on the configured test task, such as deleting or editing operations.
The above describes how to configure the test tasks, and it is emphasized again that the page used to configure the test tasks can be used as the test task configuration page, no matter how the page is displayed or obtained by how many hops.
The user may also configure various parameters of the test task, such as execution time, waiting time, interval time, etc., using the test platform described above.
S103, generating test task request data by an execution main body, and sending the test task request data to a test server so that the test server determines a target test task according to the test task request data, and the test server executes the target test task and generates test result data corresponding to the target test task;
After any test task is configured, the user directly selects to execute the test task (corresponding to selecting the test task), or one or more test tasks can be selected from the configured test tasks. Either way, the test task selected is the test task that needs to be performed next.
The execution body may generate test task request data according to an operation of a user (on a configured test task). The test task request data may include a selected configured test task, and the test task included in the test task request data may be referred to as a target test task.
Specifically, the generation of the test task request data may include determining a selected configured test task, generating test task request data according to the selected configured test task, where the test task request data includes the selected configured test task, and/or determining a configured test task, generating test task request data according to the configured test task, e.g., automatically including all configured test tasks in the test task request data.
The execution body sends the test task request data to a test server so that the test server determines a target test task according to the test task request data, and the test server executes the target test task (by running the test platform).
If the target test task is one, the test server executes the target test task.
If there are multiple target test tasks, executing the target test tasks may include determining an execution order of each target test task, and sequentially executing each target test task according to the execution order. Specifically, the test task request data may include an execution order of each test task included in the test task request data, and the test server sequentially executes each target test task according to the execution order in the test task request data, and/or the test server may preset an execution rule, where the execution rule may be used to determine an execution order of each type of test task (a web page test task, a mobile terminal test task, and an interface test task may be used as different types of test tasks).
For example, if the priority of the web page test task is higher than the priority of the mobile end test task and higher than the priority of the interface test task, the execution order may be that the web page test task precedes the mobile end test task and the mobile end test task precedes the interface test task.
The priorities of various page elements can be set, and further, for certain types of test tasks, the priorities of the test tasks can be determined according to the priorities of the page elements on the assumption that a plurality of test tasks aiming at different page elements exist. For example, for a web page test task or a mobile terminal test task, the button priority is higher than the input box, and for the web page or the mobile terminal test task, the execution sequence of the test task for the web page button is before the test task for the web page input box.
The priority of various interfaces can be set, and if a plurality of interface classes exist for testing, the execution order of the interface classes is determined according to the priority.
Currently, there may be other ways to determine the execution order of the target test tasks, and the embodiment is not limited.
After the test server executes the target test task, test result data corresponding to the target test task can be generated. The method can generate test result data corresponding to a target test task after each target test task is executed, or generate test result data for each target test task after all target test tasks in the test task request data are executed, or generate test result data for each target test task uniformly.
S105, (execution subject) acquires the test result data and generates a page for representing the test result data.
The test server may send the test result data to the execution body, and after the execution body obtains the test result data, a page for characterizing the test result data may be generated according to the test result data (parsing).
In the first embodiment, a user (i.e., a user configuring a test task) can freely configure test tasks for various objects, execute corresponding test tasks, and implement a corresponding test flow without writing test codes by the user, thereby improving test efficiency and reducing test requirements. If the test requirements need to be changed, for example, the test objects need to be changed, only the test tasks corresponding to the changed test requirements (for example, the web page test is changed to the interface test, and only the test tasks corresponding to the interface test need to be configured), and the user does not need to rewrite or change the test codes, so that the test efficiency is further improved, and the test requirements are reduced. In addition, the configuration of the test task only needs to operate the page by the user, and the user is not required to grasp the coding language or write codes, so that the user can configure the test task conveniently, and the test efficiency is improved.
Through the first embodiment, various objects including web pages, mobile terminal application programs and interfaces can be tested, the operation is convenient, and the application range is wide. By configuring the test task, the working process and the running performance of various objects can be accurately and comprehensively simulated and tested. For example, the execution time of the test task can determine the running performance and the resource occupation amount of the test object, and generally, the shorter the execution time is, the better the running performance of the test object is.
The second embodiment (hereinafter referred to as "embodiment two") of the present disclosure provides a testing method, where the execution subject of the embodiment two may be a terminal (including but not limited to a mobile phone, a computer, a pad, a television) or a server or an operating system or a testing platform or a testing system or an application program, i.e. the execution subject may be various, and may be set, used or changed according to the needs. In addition, a third party application may also assist the execution body in executing the second embodiment. For example, as shown in fig. 1, the test method in the second embodiment may be performed by a server, and an application program (corresponding to the server) may be installed on a terminal (held by a user), and data transmission may be performed between the terminal or the application program and the server, and data collection or input or output or page or information processing may be performed by the terminal or the application program, so as to assist the server in performing the test method in the second embodiment.
In particular, the execution subject of the second embodiment may be the test server in the first embodiment.
As shown in fig. 3, the test method provided in the second embodiment includes:
s202, an execution main body acquires a test request, and sends test basic configuration data to a test request party so that the test request party generates and displays a test task configuration page according to the test basic configuration data, wherein the test task configuration page is used for configuring a test task;
s204, the execution main body acquires test task request data sent by the test request party, and determines a target test task according to the test task request data;
s206, executing the target test task by the execution main body, and generating test result data corresponding to the target test task.
The execution body of the second embodiment may build the test platform described in the first embodiment.
Second embodiment reference is made to the first embodiment for details not described.
In the second embodiment, the user (i.e. the user configuring the test task) can freely configure the test task for various objects, and execute the corresponding test task, so as to implement the corresponding test flow without writing test codes by the user, thereby improving the test efficiency and reducing the test requirements. If the test requirements need to be changed, for example, the test objects need to be changed, only the test tasks corresponding to the changed test requirements (for example, the web page test is changed to the interface test, and only the test tasks corresponding to the interface test need to be configured), and the user does not need to rewrite or change the test codes, so that the test efficiency is further improved, and the test requirements are reduced. In addition, the configuration of the test task only needs to operate the page by the user, and the user is not required to grasp the coding language or write codes, so that the user can configure the test task conveniently, and the test efficiency is improved.
Through the second embodiment, various objects including web pages, mobile terminal application programs and interfaces can be tested, the operation is convenient, and the application range is wide. By configuring the test task, the working process and the running performance of various objects can be accurately and comprehensively simulated and tested. For example, the execution time of the test task can determine the running performance and the resource occupation amount of the test object, and generally, the shorter the execution time is, the better the running performance of the test object is.
As shown in fig. 4, a third embodiment of the present specification provides a test apparatus, including:
the test request module 301 is configured to display a test task configuration page after a test condition is triggered, or send a test request to a test server after the test condition is triggered, obtain test basic configuration data sent by the test server, and generate and display a test task configuration page according to the test basic configuration data, wherein the test task configuration page is used for configuring a test task;
The test initiation module 303 is configured to generate test task request data, send the test task request data to a test server, so that the test server determines a target test task according to the test task request data, and the test server executes the target test task and generates test result data corresponding to the target test task;
and the test expression module 305 is used for acquiring the test result data and generating a page for representing the test result data.
Optionally, the test task includes a web page test task and/or an application program test task;
for a web page test task, configuring the test task includes:
determining a webpage to be tested;
Positioning page elements to be tested of the webpage to be tested;
creating a test task for the page element to be tested;
and/or the number of the groups of groups,
For a mobile terminal test task, configuring the test task includes:
determining an application program to be tested;
Positioning a page to be tested of the application program to be tested and page elements to be tested of the page to be tested, and creating a test task aiming at the page elements to be tested;
or creating a test task for the application to be tested.
Optionally, the test task for the page element to be tested includes performing clicking and/or inputting on the page element to be tested.
Optionally, the test task includes an interface test task;
The configuration test tasks include:
determining a to-be-tested interface and a testing environment of the to-be-tested interface;
And creating a test task for the interface to be tested.
Optionally, the test task for the interface to be tested includes executing get and/or post and/or delete and/or put on the interface to be tested.
Optionally, the test task configuration page includes a test task configuration home page and/or a lower page of the test task configuration home page and/or a page to which the test task configuration home page is jumped one or more times for configuring a test task.
Optionally, if the test basic configuration data sent by the test server is obtained, the test basic configuration data includes a configured test task.
Optionally, the test task request data includes the selected configured test task;
and/or the number of the groups of groups,
The target test task is a test task included in the test task request data.
Optionally, generating the test task request data includes:
Determining a selected configured test task, and generating test task request data according to the selected configured test task;
and/or the number of the groups of groups,
And determining the configured test task, and generating test task request data according to the configured test task.
Optionally, the target test tasks are multiple, and executing the target test tasks includes:
determining the execution sequence of each target test task;
And sequentially executing the target test tasks according to the execution sequence.
As shown in fig. 5, a fourth embodiment of the present specification provides a test apparatus, including:
The test receiving module 402 is configured to obtain a test request, send test basic configuration data to a test requester, and enable the test requester to generate and display a test task configuration page according to the test basic configuration data, where the test task configuration page is configured to configure a test task;
the test judgment module 404 is configured to obtain test task request data sent by the test requester, and determine a target test task according to the test task request data;
and the test execution module 406 is configured to execute the target test task and generate test result data corresponding to the target test task.
Optionally, the apparatus further includes:
the configuration module is used for building a test platform, and the test platform is used for executing the target test task.
A fifth embodiment of the present specification provides a test apparatus, comprising:
at least one processor;
And
A memory communicatively coupled to the at least one processor;
wherein,
The memory stores instructions executable by the at least one processor to enable the at least one processor to perform the test method of the first or second embodiments.
A sixth embodiment of the present disclosure provides a computer-readable storage medium storing computer-executable instructions that, when executed by a processor, implement the test method of the first or second embodiment.
The embodiments described above may be combined, and modules having the same names between different embodiments or within the same embodiment may be the same or different modules.
The foregoing describes certain embodiments of the present disclosure, other embodiments being within the scope of the following claims. In some cases, the actions or steps recited in the claims can be performed in a different order than in the embodiments and still achieve desirable results. Furthermore, the processes depicted in the accompanying drawings do not necessarily have to be in the particular order shown, or sequential order, to achieve desirable results. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.
In this specification, each embodiment is described in a progressive manner, and identical and similar parts of each embodiment are all referred to each other, and each embodiment mainly describes differences from other embodiments. In particular, for apparatus, devices, non-transitory computer readable storage medium embodiments, the description is relatively simple, as it is substantially similar to method embodiments, with reference to portions of the description of method embodiments being relevant.
The apparatus, the device, the nonvolatile computer readable storage medium and the method provided in the embodiments of the present disclosure correspond to each other, and therefore, the apparatus, the device, and the nonvolatile computer storage medium also have similar advantageous technical effects as those of the corresponding method, and since the advantageous technical effects of the method have been described in detail above, the advantageous technical effects of the corresponding apparatus, device, and nonvolatile computer storage medium are not described herein again.
In the 90 s of the 20 th century, improvements to one technology could clearly be distinguished as improvements in hardware (e.g., improvements to circuit structures such as diodes, transistors, switches, etc.) or software (improvements to the process flow). However, with the development of technology, many improvements of the current method flows can be regarded as direct improvements of hardware circuit structures. Designers almost always obtain corresponding hardware circuit structures by programming improved method flows into hardware circuits. Therefore, an improvement of a method flow cannot be said to be realized by a hardware entity module. For example, a programmable logic device (Programmable Logic Device, PLD) (e.g., field programmable gate array (Field Programmable GATE ARRAY, FPGA)) is an integrated circuit whose logic functions are determined by user programming of the device. A designer programs to "integrate" a digital system onto a PLD without requiring the chip manufacturer to design and fabricate application-specific integrated circuit chips. Moreover, nowadays, instead of manually manufacturing integrated circuit chips, such programming is mostly implemented with "logic compiler (logic compiler)" software, which is similar to the software compiler used in program development and writing, and the original code before being compiled is also written in a specific programming language, which is called hardware description language (Hardware Description Language, HDL), but HDL is not just one, but a plurality of kinds, such as ABEL(Advanced Boolean Expression Language)、AHDL(Altera Hardware Description Language)、Confluence、CUPL(Cornell University Programming Language)、HDCal、JHDL(Java Hardware Description Language)、Lava、Lola、MyHDL、PALASM、RHDL(Ruby Hardware Description Language), and VHDL (Very-High-SPEED INTEGRATED Circuit Hardware Description Language) and Verilog are currently most commonly used. It will also be apparent to those skilled in the art that a hardware circuit implementing the logic method flow can be readily obtained by merely slightly programming the method flow into an integrated circuit using several of the hardware description languages described above.
The controller may be implemented in any suitable manner, for example, the controller may take the form of, for example, a microprocessor or processor and a computer readable medium storing computer readable program code (e.g., software or firmware) executable by the (micro) processor, logic gates, switches, application SPECIFIC INTEGRATED Circuits (ASICs), programmable logic controllers, and embedded microcontrollers, examples of which include, but are not limited to, ARC 625D, atmel AT91SAM, microchip PIC18F26K20, and Silicone Labs C8051F320, and the memory controller may also be implemented as part of the control logic of the memory. Those skilled in the art will also appreciate that, in addition to implementing the controller in a pure computer readable program code, it is well possible to implement the same functionality by logically programming the method steps such that the controller is in the form of logic gates, switches, application specific integrated circuits, programmable logic controllers, embedded microcontrollers, etc. Such a controller may thus be regarded as a kind of hardware component, and means for performing various functions included therein may also be regarded as structures within the hardware component. Or even means for achieving the various functions may be regarded as either software modules implementing the methods or structures within hardware components.
The system, apparatus, module or unit set forth in the above embodiments may be implemented in particular by a computer chip or entity, or by a product having a certain function. One typical implementation is a computer. In particular, the computer may be, for example, a personal computer, a laptop computer, a cellular telephone, a camera phone, a smart phone, a personal digital assistant, a media player, a navigation device, an email device, a game console, a tablet computer, a wearable device, or a combination of any of these devices.
For convenience of description, the above devices are described as being functionally divided into various units, respectively. Of course, the functions of each element may be implemented in one or more software and/or hardware elements when implemented in the present specification.
It will be appreciated by those skilled in the art that the present description may be provided as a method, system, or computer program product. Accordingly, the present specification embodiments may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present description embodiments may take the form of a computer program product on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) having computer-usable program code embodied therein.
The present description is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the specification. It will be understood that each flow and/or block of the flowchart illustrations and/or block diagrams, and combinations of flows and/or blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
In one typical configuration, a computing device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory.
The memory may include volatile memory in a computer-readable medium, random Access Memory (RAM) and/or nonvolatile memory, such as Read Only Memory (ROM) or flash memory (flash RAM). Memory is an example of computer-readable media.
Computer readable media, including both non-transitory and non-transitory, removable and non-removable media, may implement information storage by any method or technology. The information may be computer readable instructions, data structures, modules of a program, or other data. Examples of storage media for a computer include, but are not limited to, phase change memory (PRAM), static Random Access Memory (SRAM), dynamic Random Access Memory (DRAM), other types of Random Access Memory (RAM), read Only Memory (ROM), electrically Erasable Programmable Read Only Memory (EEPROM), flash memory or other memory technology, compact disc read only memory (CD-ROM), digital Versatile Disks (DVD) or other optical storage, magnetic cassettes, magnetic tape disk storage or other magnetic storage devices, or any other non-transmission medium, which can be used to store information that can be accessed by a computing device. Computer-readable media, as defined herein, does not include transitory computer-readable media (transmission media), such as modulated data signals and carrier waves.
It should also be noted that the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising one does not exclude the presence of other like elements in a process, method, article, or apparatus that comprises an element.
The description may be described in the general context of computer-executable instructions, such as program modules, being executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, etc. that perform particular tasks or implement particular abstract data types. The specification may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both local and remote computer storage media including memory storage devices.
In this specification, each embodiment is described in a progressive manner, and identical and similar parts of each embodiment are all referred to each other, and each embodiment mainly describes differences from other embodiments. In particular, for system embodiments, since they are substantially similar to method embodiments, the description is relatively simple, as relevant to see a section of the description of method embodiments.
The foregoing description is by way of example only and is not intended as limiting the application. Various modifications and variations of the present application will be apparent to those skilled in the art. Any modification, equivalent replacement, improvement, etc. which come within the spirit and principles of the application are to be included in the scope of the claims of the present application.