CN113688043A

CN113688043A - Application program testing method, device, server, iOS device and medium

Info

Publication number: CN113688043A
Application number: CN202110984169.5A
Authority: CN
Inventors: 郑晓晨; 高栋南; 潘文杰; 陈光辉; 张亚南; 赵敏
Original assignee: Beijing Sankuai Online Technology Co Ltd
Current assignee: Beijing Sankuai Online Technology Co Ltd
Priority date: 2021-08-25
Filing date: 2021-08-25
Publication date: 2021-11-23
Anticipated expiration: 2041-08-25
Also published as: CN113688043B

Abstract

The application provides an application program testing method, an application program testing device, a server, iOS equipment and a medium, and belongs to the technical field of computers. According to the method, the screen copy service is called, so that the start instruction is sent to the iOS devices through the screen copy service, the iOS devices are instructed to start the target application program at the same time, the page screenshots of the target application program are obtained, and then when the situation that all the iOS devices obtain the screenshots of the target application program is detected, the mobile terminal automatic test frame is called, so that the screenshot storage instruction is sent to the iOS devices through the mobile terminal automatic test frame, so that the iOS devices can store and transmit the page screenshots at the same time, the test data of the target application program on the iOS devices are determined based on the received page screenshots, the target application programs on the iOS devices are tested at the same time, and the test efficiency of the target application program is improved.

Description

Application program testing method, device, server, iOS device and medium

Technical Field

The present application relates to the field of computer technologies, and in particular, to an application program testing method, apparatus, server, iOS device, and medium.

Background

With the development of computer technology, various types of Application programs (APPs) are emerging. Before the APP comes on line, special test processes such as time-consuming speed measurement and page loading speed test are started often, so that the running condition of the APP can be tested, the defects of the APP can be found in time, the defects found are improved, and the APP on the line can meet the use requirements of users.

At present, when testing the running condition of an APP on an iOS device, an xrecord-QuickTime instruction is mainly triggered on a Mac server to trigger the iOS device to record a screen, then an ffmpeg instruction is triggered on the Mac server to trigger the iOS device to frame a recorded video, a corresponding screenshot is obtained based on a result after the framing, and then the starting speed, the page loading speed and the like of the APP are determined according to the obtained screenshot.

In the implementation process, one Mac server adopts the mode and can only test the APP on one iOS device at the same time, so that the test efficiency is low.

Disclosure of Invention

The embodiment of the application provides an application program testing method, device, server, iOS equipment and medium, and the APP on the plurality of iOS equipment can be tested, so that the testing efficiency is improved. The technical scheme of the application is as follows:

in one aspect, an application program testing method is provided, and the method includes:

calling a screen copy service, and sending a starting instruction to a plurality of iOS devices through the screen copy service, wherein the screen copy service is used for providing a function of acquiring a page screenshot of a target application program, and the starting instruction is used for instructing to start the target application program and acquiring the page screenshot of the target application program;

if the situation that the plurality of iOS devices acquire the page screenshots of the target application program is detected, calling a mobile terminal automatic test frame, and sending a screenshot storage instruction to the plurality of iOS devices through the mobile terminal automatic test frame, wherein the mobile terminal automatic test frame is used for providing an application program test function, and the screenshot storage instruction is used for indicating the plurality of iOS devices to store and transmit the acquired page screenshots;

based on the received page screen shots, determining test data of the target application on the plurality of iOS devices.

In one possible implementation, the test data is time-consuming to start;

determining test data of the target application on the plurality of iOS devices based on the received page screen shots, including:

for any iOS device, determining an application starting initial frame and an application starting end frame based on a page screenshot corresponding to the iOS device, wherein the application starting initial frame is the page screenshot corresponding to the target application program when starting, and the application starting end frame is the page screenshot corresponding to the target application program when finishing starting;

and determining starting time-consuming data of the target application program on any iOS device based on the timestamp of the application starting frame and the timestamp of the application starting ending frame.

In one possible implementation, the method further includes:

acquiring screen sizes of the plurality of iOS devices, wherein the screen sizes of the plurality of iOS devices are acquired through a screen copy service;

the application starts a determination process of an end frame, comprising:

determining the difference degree of the fingerprint data of any page screenshot and other page screenshots corresponding to any iOS device based on any page screenshot corresponding to any iOS device and the screen size of any iOS device, wherein the fingerprint data is used for indicating the pixel distribution condition in the page screenshot;

when the difference degree is smaller than a first preset threshold value, determining a difference image based on the pixel value mean value of any page screenshot and the pixel value mean values of other page screenshots, wherein the difference image is a part of any page screenshot in which the pixel value mean value is smaller than a second preset threshold value;

and if the standard deviation of the pixel values of the difference image is smaller than a third preset threshold, determining the screenshot of any page as the application starting end frame.

In one possible implementation manner, before invoking a screen copy service and sending a start instruction to the iOS devices through the screen copy service, the method further includes:

reading a page configuration file, wherein the page configuration file is used for indicating the page jump sequence of each page of the target application program;

in a case where the plurality of iOS devices have acquired the page screenshot of the target application, after sending a screenshot storing instruction to the plurality of iOS devices, the method further includes:

and sending a page jump instruction to the plurality of iOS devices based on the page configuration file, wherein the page jump instruction is used for indicating the plurality of iOS devices to display each page of the target application program according to the page jump sequence indicated by the page configuration file.

In one possible implementation, the test data includes page loading time-consuming data;

for any iOS device, determining a page loading start frame and a page loading end frame based on a page screenshot corresponding to the any iOS device and the screen size of the any iOS device, wherein the page loading start frame is a page screenshot corresponding to the target application program before page jump is performed, and the page loading end frame is a page screenshot corresponding to the target application program when page jump is completed;

and determining page loading time-consuming data of the target application program on any iOS device based on the timestamp of the page loading starting frame and the timestamp of the page loading ending frame.

In one possible implementation, the method further includes:

and after receiving the page screenshot, sending a storage stop instruction to the plurality of iOS devices, wherein the storage stop instruction is used for instructing the plurality of iOS devices to stop storing and transmitting the page screenshot of the target application program.

and starting a fixed-length thread pool, wherein the fixed-length thread pool is used for storing screenshot obtaining tasks of the iOS equipment with the target number, and the screenshot obtaining tasks are used for obtaining page screenshots of target application programs in the iOS equipment.

responding to a starting instruction, starting a target application program, and acquiring a page screenshot of the target application program, wherein the starting instruction is sent by a server through a screen copy service, and the screen copy service is used for providing an acquiring function of the page screenshot of the target application program;

responding to a screenshot storage instruction, and storing the page screenshot, wherein the screenshot storage instruction is sent by a server through a mobile terminal automatic test frame which is used for providing an application program test function;

and sending the screenshot of the page.

In one possible implementation, in response to a screenshot storing instruction, storing the page screenshot includes:

enabling the iOS mobile test framework, and responding to the screenshot storing instruction through the iOS mobile test framework to store the page screenshot.

In a possible implementation manner, in response to a start instruction, a target application is started, and after a page screenshot of the target application is acquired, the method further includes:

caching the acquired page screenshot by adopting a queue structure;

the responding to the screenshot storing instruction, storing the page screenshot, comprising:

responding to the screenshot storage instruction, and packaging the page screenshot in the cache;

and storing the encapsulated page screenshot.

In one possible implementation, sending the page screenshot includes:

and sending the page screenshot through a socket interface.

In one possible implementation, the method further includes:

responding to the starting instruction, and acquiring the screen size of the iOS device;

sending the screen size;

the screen size is used for determining an application start ending frame and a page loading ending frame of the target application program, the application start ending frame is a corresponding page screenshot when the target application program is started, and the page loading ending frame is a corresponding page screenshot when the target application program completes page jump.

In one aspect, an application testing apparatus is provided, the apparatus including:

the system comprises a calling module, a screen copying module and a display module, wherein the calling module is used for calling screen copying service which is used for providing a function of acquiring a page screenshot of a target application program;

the sending module is used for sending a starting instruction to the iOS devices through the screen copy service, wherein the starting instruction is used for indicating the starting of the target application program and acquiring a page screenshot of the target application program;

the calling module is further configured to call a mobile terminal automatic test framework if it is detected that the plurality of iOS devices have acquired the page screenshot of the target application program, where the mobile terminal automatic test framework is used to provide an application program test function;

the sending module is further configured to send a screenshot storing instruction to the multiple iOS devices through the mobile terminal automatic test framework, where the screenshot storing instruction is used to instruct the multiple iOS devices to store and transmit the acquired page screenshot;

a determining module for determining test data of the target application on the plurality of iOS devices based on the received page screen shots.

In one possible implementation, the test data is time-consuming to start;

the determining module is used for determining an application starting initial frame and an application starting end frame for any iOS device based on the corresponding page screenshot of the iOS device, wherein the application starting initial frame is the corresponding page screenshot when the target application program starts to be started, and the application starting end frame is the corresponding page screenshot when the target application program finishes to be started; and determining starting time-consuming data of the target application program on any iOS device based on the timestamp of the application starting frame and the timestamp of the application starting ending frame.

In one possible implementation, the apparatus further includes:

the device comprises an acquisition module, a processing module and a display module, wherein the acquisition module is used for acquiring the screen sizes of the iOS devices, and the screen sizes of the iOS devices are acquired through a screen copy service;

the application starts a determination process of an end frame, comprising:

In one possible implementation, the apparatus further includes:

the reading module is used for reading a page configuration file, and the page configuration file is used for indicating the page jump sequence of each page of the target application program;

the sending module is further configured to send a page jump instruction to the multiple iOS devices based on the page configuration file, where the page jump instruction is used to instruct the multiple iOS devices to display each page of the target application program according to a page jump sequence indicated by the page configuration file.

the determining module is used for determining a page loading start frame and a page loading end frame for any iOS device based on a page screenshot corresponding to the any iOS device and the screen size of the any iOS device, wherein the page loading start frame is a page screenshot corresponding to the target application program before page jump is carried out, and the page loading end frame is a page screenshot corresponding to the target application program when page jump is completed; and determining page loading time-consuming data of the target application program on any iOS device based on the timestamp of the page loading starting frame and the timestamp of the page loading ending frame.

In a possible implementation manner, the sending module is further configured to send, after receiving the page screenshot, a storage stop instruction to the multiple iOS devices, where the storage stop instruction is used to instruct the multiple iOS devices to stop storing and transmitting the page screenshot of the target application.

In one possible implementation, the apparatus further includes:

and the starting module is used for starting a fixed-length thread pool, the fixed-length thread pool is used for storing screenshot obtaining tasks of the iOS equipment with the target quantity, and the screenshot obtaining tasks are used for obtaining page screenshots of target application programs in the iOS equipment.

the starting module is used for responding to a starting instruction and starting the target application program, the starting instruction is sent by the server through a screen copy service, and the screen copy service is used for providing a function of acquiring a page screenshot of the target application program;

the acquisition module is used for acquiring a page screenshot of the target application program;

the storage module is used for responding to a screenshot storage instruction, storing the page screenshot, wherein the screenshot storage instruction is sent by a server through a mobile terminal automatic test frame, and the mobile terminal automatic test frame is used for providing an application program test function;

and the sending module is used for sending the page screenshot.

In a possible implementation manner, the storage module is configured to enable an iOS mobile test framework, and store the page screenshot in response to the screenshot storing instruction through the iOS mobile test framework.

In one possible implementation, the apparatus further includes:

the caching module is used for caching the acquired page screenshot by adopting a queue structure;

the storage module is used for responding to the screenshot storage instruction and packaging the page screenshot in the cache; and storing the encapsulated page screenshot.

In a possible implementation manner, the sending module is configured to send the screenshot of the page through a socket interface.

In a possible implementation manner, the obtaining module is further configured to obtain, in response to the start instruction, a screen size of the iOS device;

the sending module is also used for sending the screen size;

In one aspect, a server is provided that includes one or more processors and one or more memories having at least one program code stored therein, the program code being loaded and executed by the one or more processors to perform operations performed by the application testing method.

In one aspect, an iOS device is provided that includes one or more processors and one or more memories having at least one program code stored therein, the program code being loaded and executed by the one or more processors to implement operations performed by the application test method.

In one aspect, a computer-readable storage medium having at least one program code stored therein is provided, the program code being loaded and executed by a processor to implement the operations performed by the application testing method.

In one aspect, a computer program product is provided that includes computer code that is loaded and executed by a processor to perform the operations performed by the application testing method.

The method comprises the steps of calling a screen copy service so as to send a starting instruction to a plurality of iOS devices through the screen copy service to indicate the plurality of iOS devices to start a target application program at the same time and acquire a page screenshot of the target application program, and then calling a mobile terminal automatic test frame when detecting that each iOS device has acquired the screenshot of the target application program, so that a screenshot storage instruction is sent to the plurality of iOS devices through the mobile terminal automatic test frame so as to store and transmit the page screenshot by the plurality of iOS devices at the same time, and therefore test data of the target application program on the plurality of iOS devices is determined based on the received page screenshot, the target application programs on the plurality of iOS devices are tested at the same time, and the test efficiency of the target application program is improved.

Drawings

In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings needed to be used in the description of the embodiments are briefly introduced below, and it is obvious that the drawings in the following description are only some embodiments of the present application, and it is obvious for those skilled in the art to obtain other drawings based on these drawings without creative efforts.

FIG. 1 is a schematic diagram of an implementation environment of an application testing method according to an embodiment of the present disclosure;

FIG. 2 is a flowchart of an application testing method provided in an embodiment of the present application;

FIG. 3 is a schematic diagram illustrating a screenshot of a page provided in an embodiment of the present application;

FIG. 4 is a flowchart of an application testing method provided in an embodiment of the present application;

FIG. 5 is a flowchart of an application testing method provided in an embodiment of the present application;

FIG. 6 is a schematic diagram illustrating a screenshot of a page provided in an embodiment of the present application;

FIG. 7 is a flowchart of an application testing method provided in an embodiment of the present application;

FIG. 8 is a flowchart of an application testing method provided in an embodiment of the present application;

FIG. 9 is a schematic structural diagram of an application testing apparatus according to an embodiment of the present application;

FIG. 10 is a schematic structural diagram of an application testing apparatus according to an embodiment of the present application;

fig. 11 is a schematic structural diagram of an iOS apparatus provided in an embodiment of the present application;

fig. 12 is a schematic structural diagram of a server according to an embodiment of the present application.

Detailed Description

To make the objects, technical solutions and advantages of the present application more clear, embodiments of the present application will be described in further detail below with reference to the accompanying drawings.

Fig. 1 is a schematic diagram of an implementation environment of an application testing method provided in an embodiment of the present application, and referring to fig. 1, the implementation environment includes: a server 101 and an iOS device 102.

The server 101 is at least one of a server, a plurality of servers, a cloud computing platform, and a virtualization center. The server 101 and the iOS device 102 are connected by wired or wireless communication, which is not limited in the embodiment of the present application. The server 101 can remotely control the iOS device 102 to start the target application program, remotely control the iOS device 102 to implement page jump in the target application program, and obtain a page screenshot of the iOS device 102 in the program starting or page jump process, thereby determining test data of the target application program on the iOS device 102 based on the obtained page screenshot. Optionally, the number of the servers is greater or less, and the embodiment of the present application does not limit this. Of course, in more possible implementations, the server 101 also includes other functional servers in order to provide more comprehensive and diverse services.

The iOS device 102 is a smartphone, a tablet computer, a smart watch, a desktop computer, a notebook computer, or the like, which is loaded with an iOS operating system. The iOS device 102 and the server 101 are connected by wired or wireless communication, which is not limited in the embodiment of the present application. The iOS device 102 can implement starting of the target application program and page jump in the target application program under remote control of the server 101, and obtain a page screenshot of the target application program in a starting process and a page jump process of the target application program, thereby sending the obtained page screenshot to the server 101.

The iOS device 102 generally refers to one of a plurality of iOS devices, and the embodiment of the present application is illustrated only by the iOS device 102. Those skilled in the art will appreciate that the above-described iOS devices may be more or less numerous in more possible implementations. For example, the number of iOS devices is only a few, or the number of iOS devices is tens or hundreds, or more, and the number and the device type of the iOS devices 102 are not limited in the embodiment of the present application.

Fig. 2 is a flowchart of an application testing method provided in an embodiment of the present application, and referring to fig. 2, the method includes:

201. the method comprises the steps that a server calls a screen copy service, and sends a starting instruction to a plurality of iOS devices through the screen copy service, the screen copy service is used for providing a function of acquiring a page screenshot of a target application program, and the starting instruction is used for indicating the target application program to be started and acquiring the page screenshot of the target application program.

The Server is an apple computer Server (Mac Server), the plurality of iOS devices can all access the Server, and optionally, the Server is connected with each iOS device through usbmux d, or the Server is connected with each iOS device through other wired or wireless connection methods, which is not limited in the embodiment of the present application. The server stores a test script for testing an Application program (APP), and the test script comprises a series of instructions for indicating operations to be executed in a test process, so that the server can test the APP based on the test script after reading the test script.

In a possible implementation manner, the test script is written by a developer and then uploaded to the server, and after the server obtains the test script uploaded by the developer, the server performs a subsequent test process based on the obtained test script, that is, based on the obtained test script, steps 201 to 206 are performed.

During the testing process, the Server can provide various types of services, such as a screen copy service (Minicap Server), and different types of services correspond to different threads, so that the corresponding threads are started by calling a certain type of service, and corresponding functions are provided, so as to ensure the smooth operation of the testing process. For example, the corresponding thread can be called through the screen copy service, so that the page screenshot is obtained based on the AVFoundation framework and the Core media library.

In one possible implementation, the server calls the screen copy service, through the screen copy service, a high-speed screenshot thread is called, and through the high-speed screenshot thread, the server can send an instruction to the iOS device so as to initialize a target application program on the iOS device, can simulate some click operations on the iOS device, and remotely controls the iOS device to perform screenshot. For example, the server sends a start instruction to the iOS device through the screen copy service to simulate a click operation on an icon of the target application program, thereby implementing remote control of start of the target application program and acquisition of a page screenshot of the target application program.

Different iOS devices are corresponding to one high-speed screenshot thread, each high-speed screenshot thread corresponds to one screenshot port, namely, each iOS device is corresponding to one screenshot port, so that when each iOS device interacts with a server, information or instructions can be transmitted through the corresponding screenshot port, and transmission efficiency is improved.

In more possible implementation manners, the server may further obtain, through the screen copy service, screen sizes of the multiple iOS devices, where the screen sizes are used to determine an application start end frame and a page load end frame of the target application program, the application start end frame is a page screenshot corresponding to when the target application program is started, and the page load end frame is a page screenshot corresponding to when the target application program completes page jump, so as to subsequently determine test data of the target application program on each iOS device based on the screen sizes, where a specific process is referred to in step 206 below, and details are not described here again.

Optionally, before the server performs step 201, a fixed-length thread pool is started, where the fixed-length thread pool is used to store screenshot obtaining tasks of a target number of iOS devices, and the screenshot obtaining tasks are used to obtain page screenshots corresponding to target application programs in the iOS devices.

In more possible implementations, the server starts the fixed-length thread pool at other occasions, for example, after the step 201 is executed, the fixed-length thread pool is started again, or the fixed-length thread pool is started while the step 201 is executed, and the like, which is not limited in this embodiment of the present application.

The size of the fixed-length thread pool is stored in the server in advance, and is preset by a tester through the server, or the size of the fixed-length thread pool is obtained through other modes, and the size is not limited in the embodiment of the application. The size of the fixed-length thread pool is any positive integer value, for example, the size of the fixed-length thread pool is 10, that is, the server allows 10 threads to run simultaneously, that is, the server allows 10 iOS devices to transmit page screenshots simultaneously.

And starting a corresponding number of high-speed screenshot threads by starting the fixed-length thread pool, so as to obtain the corresponding number of page screenshots of the iOS equipment. And the size of the fixed-length thread pool is set, so that the number of high-speed screenshot threads which are run by the server at the same time is limited, the processing pressure of the server is reduced, and the stable running of the server can be ensured.

202. And the iOS equipment responds to the starting instruction, starts the target application program and acquires the page screenshot of the target application program.

In a possible implementation manner, after acquiring the page screenshot of the target application, the iOS device caches the acquired page screenshot by using a queue structure, that is, stores the acquired page screenshot in a queue. Optionally, other storage structures are adopted to cache the acquired page screenshot, which is not limited in the embodiment of the present application.

203. If the situation that the plurality of iOS devices acquire the page screenshots of the target application program is detected, the server calls a mobile terminal automatic test frame, a screenshot storage instruction is sent to the plurality of iOS devices through the mobile terminal automatic test frame, the mobile terminal automatic test frame is used for providing an application program test function, and the screenshot storage instruction is used for indicating the plurality of iOS devices to store and transmit the acquired page screenshots.

In a possible implementation manner, after acquiring the page screenshot of the target application, each iOS device sends acquisition completion information to the server, where the acquisition completion information is used to indicate that the iOS device has completed acquiring the page screenshot, and after receiving the acquisition completion information sent by any iOS device, the server can determine that any iOS device has acquired the page screenshot of the target application, so as to detect whether each iOS device has acquired the page screenshot of the target application.

The above is only an exemplary detection method, and in more possible implementation manners, other methods are used for detection, which is not limited in the embodiment of the present application.

The mobile terminal automatic test framework (Appium) can automate application programs on the iOS device, thereby realizing automation of remote control of the iOS device.

In a possible implementation manner, after detecting that multiple iOS devices have acquired the page screenshot of the target application, the server invokes the mobile-side automatic test framework, so as to invoke the picture assembly storage thread through the mobile-side automatic test framework, thereby sending a screenshot storage instruction to the multiple iOS devices through the picture assembly storage thread, and implementing the following page screenshot storage and transmission processes in step 204 and step 205.

Optionally, the time for each iOS device to acquire the page screenshot of the target application is different, and accordingly, when the server detects that the process that each iOS device has acquired the page screenshot of the target application is not simultaneous, the server sends a screenshot storage instruction to each iOS device every time the server detects that one iOS device has acquired the page screenshot of the target application. For example, for a first iOS device and a second iOS device of the multiple iOS devices, after receiving the acquisition completion information of the first iOS device, the server may determine that the first iOS device has acquired the page screenshot of the target application program, and send a screenshot storage instruction to the first iOS device through the mobile terminal automatic test framework. And if the server receives the acquisition completion information of the second iOS device after sending the screenshot storing instruction to the first iOS device, the server can determine that the second iOS device has acquired the page screenshot of the target application program, and at the moment, the screenshot storing instruction is sent to the second iOS device through the mobile terminal automatic test framework.

204. The iOS device stores the page screenshot in response to a screenshot storing instruction.

In one possible implementation, the iOS device enables an iOS mobile test framework through which the page screenshot is stored in response to the screenshot storing instruction.

The iOS mobile test framework (WebDriverAgent, WDA) is installed on each iOS device in advance, and remote control over the iOS device can be achieved through the iOS mobile test framework.

The process of storing the page screenshot comprises the following steps: and the iOS equipment responds to the screenshot storage instruction, encapsulates the webpage screenshot in the cache, and further stores the encapsulated webpage screenshot. When the iOS device stores the page screenshot, the encapsulated page screenshot is written into the memory from the cache, and therefore storage of the page screenshot is achieved.

Optionally, the memory of the iOS device stores the page screenshot by using a queue structure, or the memory of the iOS device stores the page screenshot by using another storage structure, which is not limited in this embodiment of the application.

The packaging process of the page screenshot comprises the following steps: and converting the page screenshot into binary data which can be recognized by the iOS device and the server, namely Frame (Frame) data, and encapsulating Header (Header) data for the Frame data, thereby realizing the encapsulation of the page screenshot.

In another possible implementation manner, the iOS device responds to the screenshot storing instruction, and directly writes the unencapsulated screenshot in the cache into the memory, so as to implement storage of the screenshot.

205. The iOS device sends the page screenshot.

In a possible implementation manner, if the packaged page screenshot is stored in the iOS device, the iOS device sends the packaged page screenshot through a Socket interface.

In another possible implementation manner, if the non-encapsulated page screenshot is stored in the iOS device, the iOS device encapsulates the page screenshot stored in the memory before sending the page screenshot, and then sends the encapsulated page screenshot through the socket interface.

The transmission speed of the page screenshot can be improved by adopting the socket interface to transmit the page screenshot, so that the test speed of the target application program is improved. In more possible implementation manners, other protocols are used to transmit the page screenshot, which is not limited in the embodiment of the present application.

In a possible implementation manner, after the iOS device stores all the page screenshots, the page screenshots are sent one by one through the step 205; in another possible implementation manner, each time the iOS device stores one page screenshot, the stored page screenshot is sent to the server, that is, the iOS device stores and sends the page screenshot in real time, and the embodiment of the present application does not limit which execution sequence is specifically adopted.

In the above steps 203 to 205, by introducing the screenshot storing instruction, before the screenshot storing instruction is not sent to the iOS device, the iOS device only completes the acquisition and caching of the page screenshot, but the acquired page screenshot is not written into the memory, and after the screenshot storing instruction is sent to the iOS device, the iOS device writes the acquired page screenshot from the cache into the memory in response to the screenshot storing instruction, so as to implement the storage of the page screenshot, and sends the stored page screenshot to the server, so that the server continues to execute the following step 206.

206. The server determines test data of the target application on the plurality of iOS devices based on the received page screen shots.

Optionally, when the server receives the page screenshot, the queue structure is used for storing the received page screenshot, when the queue structure is used for storing the page screenshot, the received page screenshot is stored to the tail of the queue after each page screenshot is received, and after the page screenshot is stored, the newly received page screenshot can be stored continuously, so that the problem that processing is not timely caused by too fast transmission can be effectively reduced, and the storage efficiency of the page screenshot is improved.

In a possible implementation manner, the server is associated with a page screenshot database for storing the received page screenshot, so that after the server receives the page screenshot, the server stores the received page screenshot through the page screenshot database. In the page screenshot database, different test types correspond to different storage areas, and when the received page screenshot is stored, the server stores the received page screenshot into the corresponding storage area based on the test type corresponding to the instruction executed by the test script. For example, different test types correspond to different folders, and the server stores the received page screenshot into the corresponding folder based on the test type corresponding to the instruction executed by the test script. Referring to fig. 3, fig. 3 is a schematic diagram of a page screenshot provided by an embodiment of the present application, where the server shown in fig. 3 includes a plurality of storage areas (i.e., folders) for storing page screenshots of different test types.

Optionally, after receiving the page screenshot, the server sends a storage stop instruction to the multiple iOS devices, where the storage stop instruction is used to instruct the multiple iOS devices to stop storing and transmitting the page screenshot of the target application.

By sending a storage stop instruction to the plurality of iOS devices, the iOS devices reduce the processing pressure of the iOS devices by storing and transmitting page sections of the target application in response to the received section storage instruction, and accordingly, the server does not need to receive and store page sections, reducing the processing pressure of the server.

The test data is time-consuming data for starting, and correspondingly, the determination process of the test data comprises the following steps: for any iOS device, the server determines an application starting initial frame and an application starting end frame based on the page screenshot corresponding to the iOS device, wherein the application starting initial frame is the page screenshot corresponding to the target application program when starting, and the application starting end frame is the page screenshot corresponding to the target application program when finishing starting; and determining starting time-consuming data of the target application program on any iOS device based on the timestamp of the application starting frame and the timestamp of the application starting ending frame.

The process of determining the time-consuming data to start based on the timestamp of the application start frame and the timestamp of the application start end frame includes: determining a time interval corresponding to the time stamp of the application start starting frame and the time stamp of the application start ending frame as the start time consumption data, that is, determining a difference value between the time stamp of the application start ending frame and the time stamp of the application start starting frame as the start time consumption data.

The determination process of the application starting frame comprises the following steps: and the server determines the page screenshot with the minimum timestamp based on the acquired timestamp of the page screenshot, and determines the page screenshot with the minimum timestamp as the starting frame of the application.

The determining process of the application start ending frame comprises the following steps: the server determines the difference degree of the fingerprint data of any page screenshot and other page screenshots corresponding to any iOS equipment based on any page screenshot corresponding to any iOS equipment and the screen size of any iOS equipment, wherein the fingerprint data is used for indicating the pixel distribution condition in the page screenshot; when the difference degree is smaller than a first preset threshold value, determining a difference image based on the pixel value mean value of any page screenshot and the pixel value mean values of other page screenshots, wherein the difference image is a part of any page screenshot in which the pixel value mean value is smaller than a second preset threshold value; and if the standard deviation of the pixel values of the difference image is smaller than a third preset threshold, determining the screenshot of any page as the application starting end frame. The first preset threshold, the second preset threshold, and the third preset threshold are all arbitrary values, which are not limited in the embodiment of the present application.

The process for acquiring the fingerprint data of any page screenshot comprises the following steps: the server determines the screen size of any iOS device as the size of any page screenshot, different sizes correspond to different resolutions, the resolution of any page screenshot is determined based on the size of any page screenshot, the number of pixel points of any page screenshot is determined based on the resolution, a characteristic value is determined based on the determined number of the pixel points and the pixel value of each pixel point and serves as fingerprint data of any screenshot page, and each page screenshot corresponds to unique fingerprint data. The above description only takes the process of acquiring the fingerprint data of any page screenshot as an example, and the process of acquiring the fingerprint data of other page screenshots is the same as that described above, and is not repeated here.

The other page screenshots are n page screenshots with a timestamp before the timestamp of any page screenshot, where n is any positive integer value, and taking n as 3 as an example, the determining process of the application start ending frame includes: if the screen size of any iOS device is 5.8 inches, the server determines that the size of any page screenshot is 5.8 inches, and the resolution corresponding to 5.8 inches is 1125 × 2436, that is, there are 1125 pixel points in the horizontal direction and 2346 pixel points in the vertical direction of any page screenshot, so as to determine the number of pixel points of any page screenshot, so as to determine the fingerprint data of any page screenshot based on the determined number of pixel points and the pixel value of each pixel point, and correspondingly, the determination process of the fingerprint data of 3 other page screenshots is the same as that of the determined pixel points; after determining the fingerprint data of any page screenshot and 3 other page screenshots, determining the difference degree of the fingerprint data of any page screenshot and the fingerprint data of the 3 other page screenshots, when the difference degree is smaller than a first preset threshold value, determining the pixel value mean value of any page screenshot and the 3 other page screenshots, and determining the part of any page screenshot, in which the pixel value mean value is smaller than a second preset threshold value, as a difference image; and further determining the standard deviation of the pixel values of the difference image, and if the determined standard deviation of the pixel values is smaller than a third preset threshold, determining the screenshot of any page as the application starting end frame.

The above process is only described by taking the determination process of the time-consuming data for starting the target application program on one iOS device as an example, and the determination process of the time-consuming data for starting the target application program on other iOS devices is the same as the above process, and is not described here again.

Optionally, the server is further associated with a test result database, which is used for storing test data of the target application program on each iOS device, and after determining the start time-consuming data of the target application program on each iOS device, the server stores the determined start time-consuming data in the test result database, so that the corresponding start time-consuming data can be subsequently acquired from the test result database.

For the above steps 201 to 206, the processing procedure of the iOS device in the interaction process between the server and the multiple iOS devices is described by taking one iOS device as an example, and the processing procedures of other iOS devices are the same as those described above, and are not described herein again.

The process from the step 201 to the step 206 is shown in fig. 4, where fig. 4 is a flowchart of an application program testing method provided in this embodiment of the present application, a Server starts a test script to test a target application program, and then invokes a minisap Server to perform APP initialization and thread management, that is, the target application program on an iOS device is initialized through the minisap Server, and a high-level screenshot thread is invoked through thread management to trigger the iOS device to obtain a page screenshot of the target application program, and then after the Server detects that the iOS device obtains the page screenshot, the Server starts an APP to start a picture assembly storage thread, and further, through the picture assembly storage thread, the iOS device is triggered to store and send the page screenshot, so that after receiving the page screenshot, the screenshot storage thread is closed, and then the received screenshot page is analyzed, and determining a test result, namely starting time-consuming data, and storing the determined starting time-consuming data in a database.

According to the scheme provided by the embodiment of the application, the screen copy service is called, so that the start instruction is sent to the multiple iOS devices through the screen copy service, the multiple iOS devices are instructed to start the target application program at the same time, the page screenshot of the target application program is obtained, when the situation that all the iOS devices obtain the screenshot of the target application program is detected, the mobile terminal automatic test framework is called, the screenshot storage instruction is sent to the multiple iOS devices through the mobile terminal automatic test framework, so that the multiple iOS devices can store and transmit the page screenshot at the same time, the test data of the target application program on the multiple iOS devices are determined based on the received page screenshot, the target application programs on the multiple iOS devices are tested at the same time, and the test efficiency of the target application program is improved. In addition, the corresponding screenshot port is set for each iOS device, so that the problem that a plurality of iOS devices use the same port to generate conflict is reduced, and the smooth operation of the test process is guaranteed. Moreover, according to the scheme provided by the application, screen recording of the iOS equipment is not needed, framing of the recorded video is also not needed, the testing process is simpler, and therefore the execution efficiency of the testing process can be improved.

The above process is described by taking a process of determining time-consuming data for starting a target application program as an example, in more possible implementation manners, the scheme provided by the present application can also be used to determine time-consuming data for page loading of the target application program, fig. 5 is a flowchart of an application test program method provided by an embodiment of the present application, and referring to fig. 5, the method includes:

501. and the server reads a page configuration file, wherein the page configuration file is used for indicating the page jump sequence of each page of the target application program.

The page configuration (Scheme) file comprises a series of instructions for instructing page jump operation in the test process, so that the server can remotely control the target application program to perform page jump based on the page configuration file after reading the page configuration file.

And after the page configuration file is written by a tester, uploading the page configuration file to a server, after the server acquires the page configuration file, verifying the page configuration file to determine whether the format of the page configuration file is the format corresponding to the configuration file, when the page configuration file passes verification, continuing to execute the subsequent steps 502 to 509, otherwise, directly ending the test process.

502. The method comprises the steps that a server calls a screen copy service, and sends a starting instruction to a plurality of iOS devices through the screen copy service, the screen copy service is used for providing a function of acquiring a page screenshot of a target application program, and the starting instruction is used for indicating the target application program to be started and acquiring the page screenshot of the target application program.

503. And the iOS equipment responds to the starting instruction, starts the target application program and acquires the page screenshot of the target application program.

504. If the situation that the plurality of iOS devices acquire the page screenshots of the target application program is detected, the server calls a mobile terminal automatic test frame, a screenshot storage instruction is sent to the plurality of iOS devices through the mobile terminal automatic test frame, the mobile terminal automatic test frame is used for providing an application program test function, and the screenshot storage instruction is used for indicating the plurality of iOS devices to store and transmit the acquired page screenshots.

Step 502 to step 504 are the same as step 201 to step 203, and are not described herein again.

505. And the server sends a page jump instruction to the plurality of iOS devices based on the page configuration file, wherein the page jump instruction is used for indicating the plurality of iOS devices and displaying each page of the target application program according to the page jump sequence indicated by the page configuration file.

In a possible implementation manner, after detecting that the plurality of iOS devices have acquired the page screenshot of the target application, the server invokes the mobile terminal automatic test framework, so that the configuration page jump thread is invoked through the mobile terminal automatic test framework, and the iOS devices are remotely controlled to perform page jump through the configuration page jump thread.

Different iOS devices are respectively corresponding to a configuration page jump thread, each configuration page jump thread is corresponding to a page jump port, namely, each iOS device is corresponding to a page jump port, so that when the server indicates each iOS device to perform page jump, instructions can be transmitted through the corresponding page jump ports, and transmission efficiency is improved.

The reference number of step 505 does not constitute a limitation on the execution sequence of step 505, and in a more possible implementation manner, after detecting that the multiple iOS devices have acquired the page screenshot of the target application program, the server simultaneously sends the screenshot storing instruction and the page jump instruction to the multiple iOS devices, which is not limited in this embodiment of the present application.

506. And the iOS equipment responds to the page jump instruction, jumps to the corresponding page and acquires the corresponding page screenshot.

In a possible implementation manner, the iOS device starts a page jump process in response to the page jump instruction, obtains a page screenshot in the page jump process in real time in the page jump process, and caches the obtained page screenshot, where the page screenshot caching process is referred to in step 202, and details are not described here.

507. And the iOS equipment responds to the screenshot storage instruction and stores the acquired page screenshot.

508. And the iOS equipment sends the acquired page screenshot.

In the above steps 504 to 508, by introducing the screenshot storing instruction, before the screenshot storing instruction is not sent to the iOS device, the iOS device only completes the acquisition and caching of the page screenshot, but the acquired page screenshot is not written into the memory, at this time, the WDA frame on the iOS device does not operate, and after the screenshot storing instruction is sent to the iOS device, the iOS device starts to operate the WDA frame in response to the screenshot storing instruction, and writes the acquired page screenshot into the memory from the cache, thereby implementing the storage of the page screenshot, and sending the stored page screenshot to the server, thereby reducing the conflict between the Minicap server and the WDA frame in the test process, and ensuring the test process to be smoothly performed.

509. The server determines test data of the target application on the plurality of iOS devices based on the received page screen shots.

Steps 507 to 509 are similar to steps 204 to 206, and are not described herein again.

The page screenshot acquired in the page jump process is shown in fig. 6, fig. 6 is a schematic view of the page screenshot provided in the embodiment of the present application, and the server shown in fig. 6 includes a plurality of storage areas (that is, folders) for storing the page screenshots corresponding to different page jump processes in the page jump process.

The process of the foregoing steps 501 to 509 is shown in fig. 7, where fig. 7 is a flowchart of an application program testing method provided in this embodiment of the present application, a Server starts a test script to test a target application program, and then invokes a minisap Server to perform APP initialization and thread management, that is, the Server initializes the target application program on an iOS device through the minisap Server and invokes a high-level screenshot thread through thread management to trigger the iOS device to obtain a page screenshot of the target application program, and then after the Server detects that the iOS device obtains the page screenshot, the Server starts an APP to start a picture assembly storage thread to call a schema page jump thread, remotely controls the iOS device to perform page jump through the schema page jump thread, and further triggers the iOS device to perform storage and transmission of the page screenshot through the picture assembly storage thread, therefore, after the page screenshot is received, the screenshot storage thread is closed, the received page screenshot is analyzed, a test result, namely page loading time-consuming data, is determined, and the determined page loading time-consuming data is stored in the database.

According to the scheme provided by the embodiment of the application, the page configuration file is read, the screen copy service is called, so that the start instruction is sent to the multiple iOS devices through the screen copy service to instruct the multiple iOS devices to start the target application program and acquire the page screenshot of the target application program, when the situation that each iOS device acquires the screenshot of the target application program is detected, the mobile terminal automatic test frame is called, so that the screenshot storage instruction and the page jump instruction are sent to the multiple iOS devices through the mobile terminal automatic test frame, so that the multiple iOS devices can jump pages at the same time, the page screenshot is stored and transmitted in the page jump process, the test data of the target application program on the multiple iOS devices is determined based on the received page screenshot, and the target application programs on the multiple iOS devices can be tested at the same time, therefore, the testing efficiency of the target application program is improved. In addition, the corresponding screenshot port and the page jump port are arranged for each iOS device, so that the problem that a plurality of iOS devices use the same port to generate conflict is reduced, and the smooth proceeding of the test process is ensured. Moreover, according to the scheme provided by the application, screen recording of the iOS equipment is not needed, framing of the recorded video is also not needed, the testing process is simpler, and therefore the execution efficiency of the testing process can be improved.

In a more possible implementation manner, a server determines start time-consuming data and page load time-consuming data of a target application program on multiple iOS devices at the same time, referring to fig. 8, where fig. 8 is a flowchart of an application program testing method provided in an embodiment of the present application, the server (i.e., Mac set) is connected to 5 iOS devices through Usbmuxd, and when testing the target application program on the 5 iOS devices, the server calls a Minicap set, initializes the target application program through the Minicap set, and obtains a page screenshot based on an AVFoundation framework and a Core media library. When the page screenshot is obtained, the server calls the Apdium so as to control each iOS device to respectively execute automatic test processes of starting a target application program, performing page jump in the target application program and the like through the Apdium, and enable each iOS device to obtain the page screenshot of the target application program. After the plurality of iOS devices acquire the page screenshots, converting the page screenshots into binary data (including Header data and Frame data) which can be identified by the iOS devices and the server, and further transmitting the Header data and the Frame data to the server through corresponding ports (ports) after receiving screenshot storage instructions of the server, so that the server can assemble complete page screenshots based on the Header data and the Frame data after receiving the Header data and the Frame data, thereby storing the page screenshots, and analyzing based on the page screenshots to acquire test data of the target application program on the 5 iOS devices.

Fig. 8 illustrates only 5 iOS devices as an example, and in more possible implementations, the number of iOS devices is greater or smaller, which is not limited in the embodiments of the present application. In addition, the process shown in fig. 8 is only an exemplary flow description, and the specific implementation process refers to the processes shown in fig. 2 and fig. 5, which are not described herein again.

All the above optional technical solutions can be combined arbitrarily to form optional embodiments of the present application, and are not described herein again.

Fig. 9 is a schematic structural diagram of an application testing apparatus according to an embodiment of the present application, and referring to fig. 9, the apparatus includes:

a calling module 901, configured to call a screen copy service, where the screen copy service is used to provide an obtaining function of a page screenshot of a target application program;

a sending module 902, configured to send a start instruction to multiple iOS devices through the screen copy service, where the start instruction is used to instruct to start the target application and obtain a page screenshot of the target application;

the calling module 901 is further configured to call a mobile terminal automatic test framework if it is detected that the multiple iOS devices have acquired the page screenshot of the target application program, where the mobile terminal automatic test framework is used to provide an application program test function;

the sending module 902 is further configured to send a screenshot storing instruction to the multiple iOS devices through the mobile terminal automatic test framework, where the screenshot storing instruction is used to instruct the multiple iOS devices to store and transmit the acquired page screenshot;

a determining module 903, configured to determine test data of the target application on the multiple iOS devices based on the received page screenshot.

The device provided by the embodiment of the application, through calling the screen copy service, so as to send a start instruction to the multiple iOS devices through the screen copy service, so as to instruct the multiple iOS devices to start the target application program at the same time, and obtain the page screenshot of the target application program, and further when detecting that each iOS device has obtained the screenshot of the target application program, call the mobile terminal automatic test frame, so as to send a screenshot storage instruction to the multiple iOS devices through the mobile terminal automatic test frame, so as to facilitate the multiple iOS devices to store and transmit the page screenshot at the same time, thereby determining test data of the target application program on the multiple iOS devices based on the received page screenshot, realizing the test of the target application program on the multiple iOS devices at the same time, and improving the test efficiency of the target application program.

In one possible implementation, the test data is time-consuming to start;

the determining module 903 is configured to determine, for any iOS device, an application start frame and an application start end frame based on a page screenshot corresponding to the any iOS device, where the application start frame is a page screenshot corresponding to the target application program when starting is started, and the application start end frame is a page screenshot corresponding to the target application program when starting is completed; and determining starting time-consuming data of the target application program on any iOS device based on the timestamp of the application starting frame and the timestamp of the application starting ending frame.

In one possible implementation, the apparatus further includes:

the application starts a determination process of an end frame, comprising:

In one possible implementation, the apparatus further includes:

the sending module 902 is further configured to send, based on the page configuration file, a page jump instruction to the multiple iOS devices, where the page jump instruction is used to instruct the multiple iOS devices to display each page of the target application program according to a page jump sequence indicated by the page configuration file.

the determining module 903 is configured to determine, for any iOS device, a page loading start frame and a page loading end frame based on a page screenshot corresponding to the any iOS device and a screen size of the any iOS device, where the page loading start frame is a page screenshot corresponding to the target application before page jump is performed, and the page loading end frame is a page screenshot corresponding to the target application when page jump is completed; and determining page loading time-consuming data of the target application program on any iOS device based on the timestamp of the page loading starting frame and the timestamp of the page loading ending frame.

In a possible implementation manner, the sending module 902 is further configured to send, after receiving the page screenshot, a storage stop instruction to the multiple iOS devices, where the storage stop instruction is used to instruct the multiple iOS devices to stop storing and transmitting the page screenshot of the target application.

In one possible implementation, the apparatus further includes:

Fig. 10 is a schematic structural diagram of an application testing apparatus according to an embodiment of the present application, and referring to fig. 10, the apparatus includes:

a starting module 1001, configured to start a target application in response to a starting instruction, where the starting instruction is sent by a server through a screen copy service, and the screen copy service is used to provide an acquisition function of a page screenshot of the target application;

an obtaining module 1002, configured to obtain a page screenshot of the target application program;

the storage module 1003 is configured to store the page screenshot in response to a screenshot storage instruction, where the screenshot storage instruction is sent by the server through the mobile terminal automatic test framework, and the mobile terminal automatic test framework is configured to provide an application program test function;

a sending module 1004, configured to send the page screenshot.

The device provided by the embodiment of the application calls the screen copy service by reading the page configuration file so as to send a start instruction to the multiple iOS devices through the screen copy service to instruct the multiple iOS devices to start the target application program and acquire the page screenshot of the target application program, and then calls the mobile terminal automatic test frame when detecting that each iOS device has acquired the screenshot of the target application program, so as to send a screenshot storage instruction and a page jump instruction to the multiple iOS devices through the mobile terminal automatic test frame so as to facilitate the multiple iOS devices to jump pages simultaneously, and store and transmit the page screenshot in the page jump process, thereby determining test data of the target application program on the multiple iOS devices based on the received page screenshot, and realizing the simultaneous test of the target application program on the multiple iOS devices, therefore, the testing efficiency of the target application program is improved.

In a possible implementation manner, the storage module 1003 is configured to enable an iOS mobile test framework, and store the page screenshot in response to the screenshot storing instruction through the iOS mobile test framework.

In one possible implementation, the apparatus further includes:

the storage module 1003 is configured to respond to the screenshot storage instruction and encapsulate the page screenshot in the cache; and storing the encapsulated page screenshot.

In a possible implementation manner, the sending module 1004 is configured to send the screenshot of the page through a socket interface.

In a possible implementation manner, the obtaining module 1002 is further configured to obtain, in response to the start instruction, a screen size of the iOS device;

the sending module 1004 is further configured to send the screen size;

It should be noted that: in the application testing apparatus provided in the above embodiment, when testing the target application, only the division of the functional modules is illustrated, and in practical applications, the function distribution may be completed by different functional modules according to needs, that is, the internal structure of the server or the iOS device may be divided into different functional modules to complete all or part of the functions described above. In addition, the application program testing device and the application program testing method provided by the above embodiments belong to the same concept, and specific implementation processes thereof are detailed in the method embodiments and are not described herein again.

Fig. 11 is a schematic structural diagram of an iOS device according to an embodiment of the present application. The iOS device 1100 may be: smart phones, tablet computers, smart watches, desktop computers, notebook computers, and the like, which are equipped with an iOS operating system. The iOS device 1100 may also be referred to by other names such as user equipment, portable terminal, laptop terminal, desktop terminal, etc.

In general, the iOS device 1100 includes: one or more processors 1101 and one or more memories 1102.

Processor 1101 may include one or more processing cores, such as a 4-core processor, an 8-core processor, or the like. The processor 1101 may be implemented in at least one hardware form of a DSP (Digital Signal Processing), an FPGA (Field-Programmable Gate Array), and a PLA (Programmable Logic Array). The processor 1101 may also include a main processor and a coprocessor, where the main processor is a processor for Processing data in an awake state, and is also called a Central Processing Unit (CPU); a coprocessor is a low power processor for processing data in a standby state. In some embodiments, the processor 1101 may be integrated with a GPU (Graphics Processing Unit) that is responsible for rendering and rendering content that the display screen needs to display. In some embodiments, the processor 1101 may further include an AI (Artificial Intelligence) processor for processing computing operations related to machine learning.

Memory 1102 may include one or more computer-readable storage media, which may be non-transitory. Memory 1102 can also include high-speed random access memory, as well as non-volatile memory, such as one or more magnetic disk storage devices, flash memory storage devices. In some embodiments, a non-transitory computer readable storage medium in memory 1102 is used to store at least one program code for execution by processor 1101 to implement the application testing methods provided by the method embodiments herein.

In some embodiments, the iOS apparatus 1100 may further optionally comprise: a peripheral interface 1103 and at least one peripheral. The processor 1101, memory 1102 and peripheral interface 1103 may be connected by a bus or signal lines. Various peripheral devices may be connected to the peripheral interface 1103 by buses, signal lines, or circuit boards. Specifically, the peripheral device includes: at least one of radio frequency circuitry 1104, display screen 1105, camera assembly 1106, audio circuitry 1107, positioning assembly 1108, and power supply 1109.

The peripheral interface 1103 may be used to connect at least one peripheral associated with I/O (Input/Output) to the processor 1101 and the memory 1102. In some embodiments, the processor 1101, memory 1102, and peripheral interface 1103 are integrated on the same chip or circuit board; in some other embodiments, any one or two of the processor 1101, the memory 1102 and the peripheral device interface 1103 may be implemented on separate chips or circuit boards, which is not limited by this embodiment.

The Radio Frequency circuit 1104 is used to receive and transmit RF (Radio Frequency) signals, also called electromagnetic signals. The radio frequency circuit 1104 communicates with communication networks and other communication devices via electromagnetic signals. The radio frequency circuit 1104 converts an electric signal into an electromagnetic signal to transmit, or converts a received electromagnetic signal into an electric signal. Optionally, the radio frequency circuit 1104 includes: an antenna system, an RF transceiver, one or more amplifiers, a tuner, an oscillator, a digital signal processor, a codec chipset, a subscriber identity module card, and so forth. The radio frequency circuit 1104 may communicate with other iOS devices through at least one wireless communication protocol. The wireless communication protocols include, but are not limited to: metropolitan area networks, various generation mobile communication networks (2G, 3G, 4G, and 5G), Wireless local area networks, and/or WiFi (Wireless Fidelity) networks. In some embodiments, the rf circuit 1104 may further include NFC (Near Field Communication) related circuits, which are not limited in this application.

The display screen 1105 is used to display a UI (User Interface). The UI may include graphics, text, icons, video, and any combination thereof. When the display screen 1105 is a touch display screen, the display screen 1105 also has the ability to capture touch signals on or over the surface of the display screen 1105. The touch signal may be input to the processor 1101 as a control signal for processing. At this point, the display screen 1105 may also be used to provide virtual buttons and/or a virtual keyboard, also referred to as soft buttons and/or a soft keyboard. In some embodiments, the display screen 1105 may be one, provided on the front panel of the iOS device 1100; in other embodiments, the display screens 1105 may be at least two, each disposed on a different surface of the iOS device 1100 or in a folded design; in other embodiments, the display 1105 may be a flexible display disposed on a curved surface or a folded surface of the iOS device 1100. Even further, the display screen 1105 may be arranged in a non-rectangular irregular pattern, i.e., a shaped screen. The Display screen 1105 may be made of LCD (Liquid Crystal Display), OLED (Organic Light-Emitting Diode), and the like.

Camera assembly 1106 is used to capture images or video. Optionally, camera assembly 1106 includes a front camera and a rear camera. Typically, the front camera is disposed on the front panel of the iOS device and the rear camera is disposed on the back of the iOS device. In some embodiments, the number of the rear cameras is at least two, and each rear camera is any one of a main camera, a depth-of-field camera, a wide-angle camera and a telephoto camera, so that the main camera and the depth-of-field camera are fused to realize a background blurring function, and the main camera and the wide-angle camera are fused to realize panoramic shooting and VR (Virtual Reality) shooting functions or other fusion shooting functions. In some embodiments, camera assembly 1106 may also include a flash. The flash lamp can be a monochrome temperature flash lamp or a bicolor temperature flash lamp. The double-color-temperature flash lamp is a combination of a warm-light flash lamp and a cold-light flash lamp, and can be used for light compensation at different color temperatures.

The audio circuitry 1107 may include a microphone and a speaker. The microphone is used for collecting sound waves of a user and the environment, converting the sound waves into electric signals, and inputting the electric signals to the processor 1101 for processing or inputting the electric signals to the radio frequency circuit 1104 to achieve voice communication. For stereo capture or noise reduction purposes, multiple microphones may be provided, each at a different location of the iOS device 1100. The microphone may also be an array microphone or an omni-directional pick-up microphone. The speaker is used to convert electrical signals from the processor 1101 or the radio frequency circuit 1104 into sound waves. The loudspeaker can be a traditional film loudspeaker or a piezoelectric ceramic loudspeaker. When the speaker is a piezoelectric ceramic speaker, the speaker can be used for purposes such as converting an electric signal into a sound wave audible to a human being, or converting an electric signal into a sound wave inaudible to a human being to measure a distance. In some embodiments, the audio circuitry 1107 may also include a headphone jack.

The positioning component 1108 is used to locate the current geographic Location of the iOS device 1100 for purposes of navigation or LBS (Location Based Service). The Positioning component 1108 may be a Positioning component based on the united states GPS (Global Positioning System), the chinese beidou System, the russian graves System, or the european union galileo System.

The power supply 1109 is used to power the various components in the iOS device 1100. The power supply 1109 may be alternating current, direct current, disposable or rechargeable. When the power supply 1109 includes a rechargeable battery, the rechargeable battery may support wired or wireless charging. The rechargeable battery may also be used to support fast charge technology.

In some embodiments, the iOS device 1100 further includes one or more sensors 1110. The one or more sensors 1110 include, but are not limited to: acceleration sensor 1111, gyro sensor 1112, pressure sensor 1113, fingerprint sensor 1114, optical sensor 1115, and proximity sensor 1116.

The acceleration sensor 1111 can detect the magnitude of acceleration on three coordinate axes of the coordinate system established with the iOS apparatus 1100. For example, the acceleration sensor 1111 may be configured to detect components of the gravitational acceleration in three coordinate axes. The processor 1101 may control the display screen 1105 to display the user interface in a landscape view or a portrait view according to the gravitational acceleration signal collected by the acceleration sensor 1111. The acceleration sensor 1111 may also be used for acquisition of motion data of a game or a user.

The gyro sensor 1112 may detect a body direction and a rotation angle of the iOS apparatus 1100, and the gyro sensor 1112 may acquire a 3D motion of the user on the iOS apparatus 1100 in cooperation with the acceleration sensor 1111. From the data collected by gyroscope sensor 1112, processor 1101 may implement the following functions: motion sensing (such as changing the UI according to a user's tilting operation), image stabilization at the time of photographing, game control, and inertial navigation.

The pressure sensor 1113 may be disposed on a side bezel of the iOS device 1100 and/or on an underlying layer of the display screen 1105. When the pressure sensor 1113 is disposed on the side frame of the iOS apparatus 1100, the user's holding signal of the iOS apparatus 1100 can be detected, and the processor 1101 performs left-right hand recognition or shortcut operation according to the holding signal collected by the pressure sensor 1113. When the pressure sensor 1113 is disposed at the lower layer of the display screen 1105, the processor 1101 controls the operability control on the UI interface according to the pressure operation of the user on the display screen 1105. The operability control comprises at least one of a button control, a scroll bar control, an icon control and a menu control.

The fingerprint sensor 1114 is configured to collect a fingerprint of the user, and the processor 1101 identifies the user according to the fingerprint collected by the fingerprint sensor 1114, or the fingerprint sensor 1114 identifies the user according to the collected fingerprint. Upon recognizing that the user's identity is a trusted identity, the user is authorized by the processor 1101 to perform relevant sensitive operations including unlocking the screen, viewing encrypted information, downloading software, paying for and changing settings, etc. The fingerprint sensor 1114 may be disposed on the front, back, or side of the iOS device 1100. When a physical button or vendor Logo is provided on the iOS device 1100, the fingerprint sensor 1114 may be integrated with the physical button or vendor Logo.

Optical sensor 1115 is used to collect ambient light intensity. In one embodiment, the processor 1101 may control the display brightness of the display screen 1105 based on the ambient light intensity collected by the optical sensor 1115. Specifically, when the ambient light intensity is high, the display brightness of the display screen 1105 is increased; when the ambient light intensity is low, the display brightness of the display screen 1105 is reduced. In another embodiment, processor 1101 may also dynamically adjust the shooting parameters of camera assembly 1106 based on the ambient light intensity collected by optical sensor 1115.

A proximity sensor 1116, also referred to as a distance sensor, is typically provided on the front panel of the iOS device 1100. The proximity sensor 1116 is used to capture the distance between the user and the front of the iOS device 1100. In one embodiment, the display screen 1105 is controlled by the processor 1101 to switch from a bright screen state to a dark screen state when the proximity sensor 1116 detects that the distance between the user and the front face of the iOS device 1100 is gradually decreasing; when the proximity sensor 1116 detects that the distance between the user and the front of the iOS device 1100 becomes progressively larger, the display screen 1105 is controlled by the processor 1101 to switch from a breath-screen state to a bright-screen state.

Those skilled in the art will appreciate that the architecture shown in fig. 11 does not constitute a limitation of the iOS device 1100, and may include more or fewer components than those shown, or combine certain components, or employ a different arrangement of components.

Fig. 12 is a schematic structural diagram of a server 1200 according to an embodiment of the present application, where the server 1200 may generate a relatively large difference due to a difference in configuration or performance, and may include one or more processors (CPUs) 1001 and one or more memories 1202, where the one or more memories 1202 store at least one program code, and the at least one program code is loaded and executed by the one or more processors 1201 to implement the methods provided by the foregoing method embodiments. Certainly, the server 1200 may further have components such as a wired or wireless network interface, a keyboard, and an input/output interface, so as to perform input and output, and the server 1200 may further include other components for implementing the functions of the device, which is not described herein again.

In an exemplary embodiment, a computer-readable storage medium, such as a memory, including program code, which is executable by a processor to perform the application testing method in the above-described embodiments is also provided. For example, the computer-readable storage medium may be a Read-Only Memory (ROM), a Random Access Memory (RAM), a Compact Disc Read-Only Memory (CD-ROM), a magnetic tape, a floppy disk, an optical data storage device, and the like.

In an exemplary embodiment, a computer program product is also provided, which comprises computer program code that is loaded and executed by a processor of a server to perform the method steps of the application testing method provided in the above embodiments.

It will be understood by those skilled in the art that all or part of the steps for implementing the above embodiments may be implemented by hardware, or may be implemented by hardware associated with program code, and the program may be stored in a computer readable storage medium, where the above mentioned storage medium may be a read-only memory, a magnetic or optical disk, etc.

The above description is only exemplary of the present application and should not be taken as limiting, as any modification, equivalent replacement, or improvement made within the spirit and principle of the present application should be included in the protection scope of the present application.

Claims

1. An application testing method, the method comprising:

if the situation that the plurality of iOS devices acquire the page screenshots of the target application program is detected, calling a mobile terminal automatic test frame, and sending screenshot storage instructions to the plurality of iOS devices through the mobile terminal automatic test frame, wherein the mobile terminal automatic test frame is used for providing an application program test function, and the screenshot storage instructions are used for indicating the plurality of iOS devices to store and transmit the acquired page screenshots;

determining test data of the target application on the plurality of iOS devices based on the received page screen shots.

2. The method of claim 1, wherein the test data is boot time data;

the determining test data of the target application on the plurality of iOS devices based on the received page screenshots comprises:

3. The method of claim 2, further comprising:

the determining process of the application starting end frame comprises the following steps:

determining the difference degree of fingerprint data of any page screenshot and other page screenshots corresponding to any iOS device based on any page screenshot corresponding to any iOS device and the screen size of any iOS device, wherein the fingerprint data is used for indicating the pixel distribution condition in the page screenshot;

and if the standard deviation of the pixel values of the difference images is smaller than a third preset threshold, determining the screenshot of any page as the application starting end frame.

4. The method of claim 1, wherein the invoking a screen copy service, prior to sending a boot instruction to the plurality of iOS devices via the screen copy service, the method further comprises:

after the screenshot storing instruction is sent to the iOS devices under the condition that the iOS devices have acquired the page screenshot of the target application, the method further includes:

and sending a page jump instruction to the plurality of iOS devices based on the page configuration file, wherein the page jump instruction is used for indicating the plurality of iOS devices and displaying each page of the target application program according to a page jump sequence indicated by the page configuration file.

5. The method of claim 4, wherein the test data comprises page load time-consuming data;

and determining page loading time-consuming data of the target application program on any iOS device based on the timestamp of the page loading start frame and the timestamp of the page loading end frame.

6. The method of claim 1, further comprising:

7. The method of claim 1, wherein the invoking a screen copy service, prior to sending a boot instruction to the plurality of iOS devices via the screen copy service, the method further comprises:

and starting a fixed-length thread pool, wherein the fixed-length thread pool is used for storing screenshot obtaining tasks of the iOS equipment with the target quantity, and the screenshot obtaining tasks are used for obtaining page screenshots of target application programs in the iOS equipment.

8. An application testing method, the method comprising:

responding to a screenshot storage instruction, and storing the page screenshot, wherein the screenshot storage instruction is sent by a server through a mobile terminal automatic test frame, and the mobile terminal automatic test frame is used for providing an application program test function;

and sending the page screenshot.

9. The method of claim 8, wherein storing the page screen shot in response to a screen shot storage instruction comprises:

enabling an iOS mobile test framework, responding to the screenshot storage instruction through the iOS mobile test framework, and storing the page screenshot.

10. The method of claim 8, wherein after the target application is launched in response to the launch instruction and the screenshot of the page of the target application is obtained, the method further comprises:

caching the acquired page screenshot by adopting a queue structure;

the storing the page screenshot in response to the screenshot storing instruction comprises:

and storing the encapsulated page screenshot.

11. The method of claim 8, wherein the sending the page screenshot comprises:

and sending the page screenshot through a socket interface.

12. The method of claim 8, further comprising:

sending the screen size;

the screen size is used for determining an application starting end frame and a page loading end frame of the target application program, the application starting end frame is a corresponding page screenshot when the target application program is started, and the page loading end frame is a corresponding page screenshot when the target application program finishes page jump.

13. An application testing apparatus, the apparatus comprising:

the system comprises a calling module, a screen copying service and a display module, wherein the calling module is used for calling the screen copying service, and the screen copying service is used for providing a function of acquiring a page screenshot of a target application program;

the sending module is used for sending a starting instruction to a plurality of iOS devices through the screen copy service, wherein the starting instruction is used for indicating the starting of the target application program and acquiring a page screenshot of the target application program;

a determining module, configured to determine test data of the target application on the multiple iOS devices based on the received page screenshot.

14. An application testing apparatus, the apparatus comprising:

the system comprises a starting module, a screen copy service module and a display module, wherein the starting module is used for responding to a starting instruction and starting a target application program, the starting instruction is sent by a server through the screen copy service, and the screen copy service is used for providing a function of acquiring a page screenshot of the target application program;

the storage module is used for responding to a screenshot storage instruction and storing the page screenshot, the screenshot storage instruction is sent by a server through a mobile terminal automatic test frame, and the mobile terminal automatic test frame is used for providing an application program test function;

and the sending module is used for sending the page screenshot.

15. A server, comprising one or more processors and one or more memories having stored therein at least one program code, the program code loaded into and executed by the one or more processors to perform operations performed by the application testing method of any one of claims 1 to 7.

16. An iOS device, characterized in that the iOS device comprises one or more processors and one or more memories, in which at least one program code is stored, which is loaded and executed by the one or more processors to implement the operations performed by the application testing method according to any one of claims 8 to 12.

17. A computer-readable storage medium having at least one program code stored therein, the program code being loaded and executed by a processor to implement the operations performed by the application testing method of any one of claims 1 to 7; or operations performed by the application testing method of any of claims 8 to 12.