CN110287088B

CN110287088B - Automatic testing method based on dynamic UI model

Info

Publication number: CN110287088B
Application number: CN201910032529.4A
Authority: CN
Inventors: 曹春; 葛红军; 余萍; 马晓星
Original assignee: Nanjing University
Current assignee: Nanjing University
Priority date: 2019-01-14
Filing date: 2019-01-14
Publication date: 2021-08-31
Anticipated expiration: 2039-01-14
Also published as: CN110287088A

Abstract

The invention discloses an automatic testing method based on a dynamic UI model, which is used for guiding and accelerating a GUI (graphical user interface) exploration process, exploring more Android application GUI states within limited time and improving the testing coverage rate. In the initial stage, interface elements are characterized according to the attributes of the interface elements and structural features in the GUI tree, and are initially grouped, namely element groups; in the testing stage, an event on an interface element is triggered through a selected strategy, Activity jump after the event is triggered is collected to serve as behavior feedback, the weight of a group is adjusted or an original group is split and recombined according to the feedback result, elements of a GUI are grouped, a state model with reasonable granularity is constructed, the UI model is dynamically adjusted through collecting feedback and heuristic processes in the testing process, the problem of state explosion in the testing process is solved, and the coverage rate of automatic testing is improved within limited time.

Description

Automatic testing method based on dynamic UI model

Technical Field

The invention relates to the field of mobile application testing, in particular to an automatic testing method based on a dynamic UI model.

Background

The Android system has become a mobile end system with the highest market share. Meanwhile, the number of Android applications is also outbreak, and in 2017, the number of applications reaches 330 ten thousand in Google Play. In order to ensure the quality of the Android application, the GUI test of the Android application becomes a hot spot in current research. The testing work is also difficult, and in order to provide rich functions and good user experience, the user interface of the Android application becomes more and more complex, which brings new challenges to the testing of the Android application. In practice, a tester needs to write a test script (use case) to test the functions of the GUI, but the workload is large, time and labor are wasted, and when an application is updated, the script needs to be rewritten, so that the universality is poor.

In recent years, researchers have proposed a plurality of Android application GUI automatic testing technologies. The model-based automated testing tool is widely researched, during the testing and exploring process, the Activity and the GUI tree of the application are obtained, the current GUI state model is analyzed and constructed, the set of driving events is extracted, and a specific strategy such as DFS, BFS and the like is used for guiding the testing process to explore more activities and GUI states. According to research, the existing test method has unsatisfactory performance effect on real application, one of the main reasons is that aiming at complex GUI of real application, it is difficult to construct a reasonable state according to a specific model, and the constructed state model may be too coarse in particle size, so that many GUI states are omitted; or the granularity is too fine, the problem of state explosion is caused, the whole testing process is limited in a certain specific state, and the final coverage rate is low. From the GUI model level, the main disadvantage is that the common structural features between the interface elements are not considered, and a proper granularity is not found to divide the element "group".

Disclosure of Invention

Aiming at the problems in the prior art, the invention provides an automatic testing method based on a dynamic UI model, which accelerates the exploration process of an Android application GUI by using interface element grouping and a heuristic exploration method to perform an automatic testing mode.

The technical solution of the invention is as follows: an automated testing method based on a dynamic UI model, the method comprising the steps of:

the method comprises the following steps: acquiring and analyzing the state of the current interface, including an Activity name and a GUI tree;

step two: under the Activity, grouping all interface elements of the current GUI tree according to the class attribute and the structural feature of the elements, and modeling the current GUI state S;

step three: in a GUI state S, selecting a certain group according to the test knowledge and weight of the group, selecting a driving event according to a specific strategy in the driving events of all interface elements in the group, injecting the event, driving the interface of the application to perform state transition, and changing the GUI state into S';

step four: collecting feedback of Activity transfer conditions in the process of multiple tests, and judging whether the Activity jumps consistently;

step five: adjusting the group in which the selected element is located according to the feedback, including: and adjusting the weight, and splitting and recombining the groups.

Further, the GUI test is a black box test method.

The bug refers to the operation process that the Exception and Error thrown by the application can be captured.

Further, the acquiring of the application state in the step one means capturing a change of an interface element state of the Android device in real time, and the presentation form of the information is a hierarchical structure tree.

Furthermore, the state of the application is related to the start and jump information of the Activity, and the Activity of the current application can be acquired in real time to describe the state of the application.

The Activity is one of four main components of an Android system, is a component responsible for interacting with a user, provides a screen, and can be used for interaction by the user. Each Android application is formed by the cooperative cooperation of a plurality of loosely-linked Activities.

Further, the GUI tree in step two is a hierarchical tree, in which each node is an interface element and is a basic unit for performing GUI state modeling.

The interface element is a View node (leaf node) or a Viewgroup node (non-leaf node). Each node contains many items of detailed information: 1) class is information indicating the type of the interface component (Widget); 2) resource id, text, desc are some text information describing the component; 3) information such as clickable, scrollable and the like is information describing events which can be triggered on the component; 4) index represents the only subscript information of the Widget among the brother nodes; 5) bounds are coordinate information of the described nodes, and the information of the bounds can change frequently along with operations such as sliding of the interface.

The structural feature refers to structural information of one interface element in the whole GUI tree, and is described by using class information. The structural characteristics of each interface element node include two parts: 1) the XPath path expression from the root node to the node is in the form of:/[ class ═ FrameLayout ' ]/[ class ═ recyclerview ' ]/[ class ═ LinearLayout ' ]. 2) The structure information of the subtree with the node as the root node can be expressed by a plurality of XPath path expressions in the form of 1). The structural features are represented using Group ID.

The Group refers to a set of a plurality of interface elements which meet structural feature equivalence, the identification of the Group is a Group ID, and the identification is unique inside each Activity.

The GUI state is generally represented by a set formed by all interface elements in the prior art, and is represented by a set of groups in the invention, so that the constructed state does not have the problem of state explosion.

Further, the test knowledge in step three refers to the information about whether the interface element can explore the new GUI state, and the information is collected according to the feedback after the injection event.

The weight refers to the index weight occupied by the group in the selection strategy, and is used by the subsequent selection strategy.

The driving event refers to an event which interacts with a user on the interface element, such as clicking, sliding, text input and the like.

The selection strategy is divided into two stages: the first stage is a greedy stage, and the events of the interface elements in the group with the access times less than two times are preferentially selected; the second phase is a random phase, which refers to weighted random selection according to the weight of the group.

The injection event refers to calling a function of the event, and sending the event such as clicking, sliding, text input and the like to the tested equipment.

The state transition means that the interface of the test application is transitioned after the event is injected, the GUI state of the interface is also transitioned, and the GUI state change means Activity jump.

The model adjustment according to the feedback comprises three operations: 1) adjusting the weight value; 2) splitting the group; 3) and (4) recombining the groups.

The weight adjustment means that the weight of the group is continuously reduced from the initial weight to half of the original weight until the minimum value is reached.

The splitting of the group means that the GUI states are inconsistent due to events on the members of the interface elements of the group, which means that the interface elements of the group should not be split into one group, and the group needs to be split.

The recombination of the groups refers to that certain interface elements of the split groups are recombined into a new group according to the consistency of the jump activities of the interface elements.

Compared with the prior art, the invention has the advantages that: according to the method, a great number of interface elements in the GUI tree are grouped according to the commonality of the structural characteristics of the interface element nodes, so that the problem of state explosion is avoided; according to the feedback of the event, the existing groups are dynamically adjusted, and the knowledge learned in the test process is continuously improved; and selecting a driving event by using a heuristic method, and guiding the testing process to explore more new GUI states. The testing method greatly enhances the coverage rate of the test and improves the testing efficiency and quality.

Drawings

FIG. 1 is a diagram of the logical architecture of the present invention;

FIG. 2 is a flow chart of the test of the present invention;

FIG. 3 is an interface element grouping model of an example application;

FIG. 4 is a packet-based multi-layer state model;

FIG. 5 is a grouped feedback split reconstruction model.

Detailed Description

The technical solution of the present invention is described in detail below with reference to the accompanying drawings by specific embodiments.

As shown in fig. 1, fig. 1 is a logical architecture diagram of the present invention, including the various modules of the present invention. The system mainly comprises an Activity module, a GUI module, a grouping and modeling module, a selection and event execution module, a feedback module, a weight value updating module and a grouping splitting and recombining module.

FIG. 2 is a flow chart of the present invention, which includes all steps in the whole test process, such as the process of continuously looping in the flow chart, until the time or event limit set by the test is reached.

The method comprises the following steps: the GUI state of the application is parsed. As shown in fig. 1 for acquiring status information, parsing the GUI status of an application includes two steps: and acquiring the current Activity and GUI tree of the application.

Activity is the Activity name of the current interface of the Android application; the GUI tree is a hierarchy of views and ViewGroup corresponding to a current screen, and then, for each View or ViewGroup node, we call a Widget by analyzing the node attribute and the structural feature of the hierarchy tree.

Step two: and initially grouping and constructing a model. And according to the class attribute and the structural characteristic of the interface element, allocating a Group ID to each element of the interface element in an XPath expression mode. The attributes are the same and the Group IDs of the interface elements with equivalent structural characteristics will be the same, so they will be grouped into the same Group, called an element Group.

Specifically, as shown in the grouping module of FIG. 1, the grouper is based on the currently applied GUI tree. As shown on the left side of fig. 3, which is an interface hungry how to apply the Main Activity, it can be seen intuitively that many elements widgets have great similarity in structure. On the right side of FIG. 3 is the structure of the simplified GUI tree of the interface, with each node containing index and class attributes, including parent and child nodes.

As shown on the right side of fig. 3, for five child nodes LinearLayout of the TabWidget, the Group ID thereof includes two parts: the first part is/[ class ═ FrameLayout ' ]/[ class ═ TabWidget ' ]/[ class ═ LinearLayout ' ], and is composed of class attributes of each node on a path from the root node to the node; the second part contains its child node XPath expression/[ class ═ TextView' ]. The attributes and structures of these five nodes are consistent, so their Group IDs are consistent, and therefore are divided into one element Group.

As shown in the right side of fig. 3, for the node marked with a circle 2, the first part of the Group ID is/[ class ═ FrameLayout ']/[ class ═ recyclerview' ]/[ class ═ LinearLayout '], and the second part is/[ class ═ TextView' ]; for the nodes marked with circles 3, the first part of the Group ID/[ class ═ FrameLayout ']/[ class ═ recycleview' ]/[ class ═ LinearLayout '], and the second part thereof/[ class ═ ImageView' ]. Therefore, for nodes marked with

circles

2 and 3, their Group IDs are consistent in the first part, but inconsistent in the second part, and therefore cannot be grouped into a Group.

The element Group refers to a set of element nodes having the same Group ID, and is denoted by G ═ W0, W1, W2, … Wn, where W0 to Wn denote the elements included in the Group.

The GUI state model refers to a state represented as a set of several groups, where S is { G0, G1, G2, …, Gn }, where G0 to Gn represent elements included in the group. As shown in fig. 3, this state can be represented as S ═ { G1, G2, G3, G4 }.

Step three: a group of interface elements is selected. The next element is selected based on the current state S and historical knowledge of the element group.

The selection strategy comprises two phases:

the first phase is a greedy phase; the greedy phase means that an element group G exists in this state, which contains two or more elements, but the element group is selected less than twice. Because the Activity feedback in the test needs to compare at least the members in the group, the weight can be adjusted according to whether the jumps are consistent, and the splitting and recombination of the groups are kept unchanged.

Therefore, for the state in fig. 3, the greedy phase needs to select two unvisited elements from four groups of S ═ { G1, G2, G3, and G4} and trigger events to collect feedback to guide the dynamic adjustment of the UI model.

The second phase is a random phase. The initial weight of each group is P, the weight of each group is adjusted correspondingly in a greedy stage, and if the weights of the four groups are P1, P2, P3 and P4 respectively, a group is randomly extracted according to the probability of the weights, and a member element is randomly selected in the group.

Step four: the drive event is injected and feedback is collected. As shown in the architecture diagram of fig. 1, the element selected by the selector is used as an input, and the event executor injects a corresponding event according to the type and the attribute of the element, such as clicking, inputting text, sliding, and the like. The event sending mode is consistent with the Monkey, and corresponding actions are generated according to the coordinates of the elements and are injected into the mobile phone.

The application will respond to the event, such as jump of Activity, and after the execution of the event is finished, we will feed back the Activity a' of the jump to the feedback collector.

Step five: and carrying out model dynamic adjustment according to the feedback. The feedback collector will determine whether the jumps are consistent based on the jumps of other previous element members maintained in the global state.

If the jump is consistent, the situation shows that events on members in the element group repeatedly explore activities which have been explored before, so that the weight of the group is reduced from P to P/2; this process is iterated until the minimum weight MIN _ PRIORITY is reduced.

If the jump is not consistent, the situation shows that the elements of the group have consistent structural features, but different members can explore different activities, so that the members of the group need to be adjusted, re-split and grouped.

As shown in fig. 5, assume a group G: { W0, W1, W2, …, W9}, the group consisting of 10 members. During testing, elements marked with the same color indicate a jump to the same Activity, and elements marked with white unmarked color indicate members that have not been selected to trigger an event. In the test process, after triggering events on elements W1 and W2, W1 may cause a0 to jump to a1, W2 may cause a0 to jump to a2, and then feedback of W1 and W2 is inconsistent, and then W1 and W2 need to be split from the original group G0, which is the splitting process; if another element, W3, causes a0 to jump to a1, it is consistent with the feedback of W1, then W3 and W1 need to be recombined again; similarly, W4 is recombined with W2 again to finally form three groups G0 ═ W5-W9 } G1 ═ W1, W3} G2 ═ W2, W4}, which is a recombination process. At this time, elements such as W5-W9 are elements which have not been triggered, and they are split and recombined according to their behavior feedback in the subsequent iterative testing process. After many iterations, the initial group G0, will form three stable new groups G1, G2, G3.

Although the present invention has been described with reference to the preferred embodiments, it is not intended to be limited thereto, and various changes and modifications can be made by one skilled in the art without departing from the spirit and scope of the present invention.

Claims

1. An automatic test method based on a dynamic UI model is characterized by comprising the following five steps:

step one, analyzing the GUI state of an application;

step two, initially grouping and constructing a model;

step three, selecting an interface element group and an event;

injecting a driving event, and collecting feedback;

step five, dynamically adjusting the model according to the feedback;

analyzing the GUI state of the application refers to acquiring an Activity name of the current GUI and a Layout Structure (Layout Structure) of the GUI, wherein the Layout Structure of the GUI is called a GUI tree;

the initial grouping refers to that the elements with the same attribute and equivalent structural characteristics are divided into the same group according to the characteristic attribute and the structural characteristics of the interface elements, and the group is called an element group; constructing a GUI state model of the application based on the Activity and the element group;

selecting an interface element group refers to selecting an element group and selecting an event on an interface element member in the group;

injecting a driving event and collecting feedback refers to triggering an event on the interface element selected in the previous step, and observing Activity jump of an application after the triggering event as feedback of the event;

the dynamic model adjustment according to the feedback refers to two types of adjustment according to the feedback of the event: 1. weight adjustment 2 of element group, dynamic adjustment of group structure: and splitting the original element group, recombining and adjusting the model.

2. The automated testing method based on the dynamic UI model according to claim 1, wherein:

analyzing the Activity and the GUI tree of the current interface of the application, namely acquiring the Activity name of the current interface of the Android application and the structure of the GUI tree presented by the current screen, and then analyzing the node attribute and the structural feature of the hierarchical tree;

the characteristic attribute of the interface element in the step two refers to the class attribute, which is an attribute for describing the type of the interface element, and the structural characteristic refers to the ancestor node and the descendant node of each interface element;

by means of the characteristic attributes and the structural characteristics of the interface elements, a Group ID is constructed for each interface element in a form of a plurality of XPath expressions, the interface elements with the same Group ID are interface elements with the same type and equivalent structural characteristics, and therefore the interfaces with the same Group ID are divided into the same Group, namely an element Group;

selecting interface elements refers to selecting an element group in the current state and selecting an element member in the group according to strategies of different stages by using corresponding strategies;

driving an event on the interface element, wherein the driving event refers to an event on the interface element, and the injecting event refers to sending the event to the mobile phone in a Monkey mode, so as to drive the test process; the feedback collection means that whether the Activity state of the application jumps or not after the trigger of the event is acquired;

the step five of dynamically adjusting the model according to the feedback refers to adjusting the model according to the feedback of whether the Activity collected in the step four jumps or not;

if the jumps are consistent, the weight of the element group is reduced, and the members of the group remain unchanged; if the jumping is inconsistent, splitting the original element group, wherein the split new group weight is half of the original group, and the rest other elements of the original element group can jump according to the Activity thereof and rejoin the corresponding group in the later test process, which is the process of splitting and recombining the group.

3. The automated testing method based on the dynamic UI model according to claim 2, wherein:

the Activity refers to one of four basic components of the Android application, and is a component responsible for interacting with a user, and the Activity is a single screen on which component elements are displayed to monitor and process events of the user to respond;

the GUI tree means that interface elements of Android are organized by using a hierarchy of View and ViewGroup objects;

each ViewGroup is a layout container element used for storing other View objects; each View is a leaf node element;

the layout of the GUI tree is presented in an XML mode, each View or ViewGroup node corresponds to an XML node, and the type of the View or ViewGroup object is displayed by a class attribute, so that the attribute is used as a characteristic attribute in the element grouping process;

the Group ID is an XPath expression used for describing class attributes and structural features of an element, and a Group ID is composed of a plurality of sections of expressions, wherein the first section is a path expression from a root node to the node, and the expression represents the class attribute of each node on a path from the root node to a linear layout node; the rest part is an expression of a child node of the node,/[ class ═ TextView' ], which indicates that the node has a child node and is of the type TextView;

the element Group refers to a set of element nodes with the same Group ID, and is represented as G ═ { W0, W1, W2, … Wn }, where W0 to Wn represent the elements included in the Group;

the GUI state model refers to a state represented as a set of a plurality of groups, wherein S is { G0, G1, G2, …, Gn }, and G0-Gn represent elements contained in the groups;

the selection strategy comprises two different stages, wherein a greedy strategy is adopted in the first stage, and if a group with the number of element members more than or equal to 2 exists, the greedy strategy is adopted to preferentially select the element group with the selection times lower than two and the event of the member in the group; in the second stage, a random strategy is adopted, weighted random is carried out according to the weight of each element group, and one element group is selected;

within the selected element group, a greedy strategy is used to select a member of the group;

the weight value refers to the priority of each group, the value can be adjusted along with the testing process, if the members in the group can cause the jump of Activity to be consistent, the weight value can be reduced by half, because events on other elements of the group are redundant, new unexplored Activity states cannot be found;

the selection strategy and the weight value adjustment are based on a heuristic algorithm of a dynamic UI model.

4. The automated testing method based on the dynamic UI model according to claim 2, wherein:

the splitting and recombining of the group comprises two processes, and assuming that a group G0 is { W0, W1, W2, W3, W4} in Activity a0, after events on elements W0 and W1 are triggered, W0 causes a0 to jump to a1, W1 causes a0 to jump to a2, and feedback of W0 and W1 is inconsistent, W0 needs to be split from an original group G0, which is a splitting process; if another element W2 causes a0 to jump to a1, and it is consistent with the feedback of W0, W2 and W0 need to be recombined again, and finally two groups G0 ═ { W1, W3, W4} G1 ═ W0, W2} are formed, which is a recombination process, at this time, two elements W3 and W4 are elements which have not been triggered, and they will be split and recombined according to their behavior feedback in a later iteration test process.