CN114138662A - Context-based mobile application execution sequence reduction method - Google Patents
Context-based mobile application execution sequence reduction method Download PDFInfo
- Publication number
- CN114138662A CN114138662A CN202111495962.5A CN202111495962A CN114138662A CN 114138662 A CN114138662 A CN 114138662A CN 202111495962 A CN202111495962 A CN 202111495962A CN 114138662 A CN114138662 A CN 114138662A
- Authority
- CN
- China
- Prior art keywords
- sequence
- reduction
- statement
- execution sequence
- log
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3692—Test management for test results analysis
Abstract
The invention relates to a context-based mobile application execution sequence reduction method. Aiming at an input event sequence with a fault in android application, the method uses a static analysis technology, and aiming at a specified package, all methods in the specified package are called, and a log output statement is inserted through socket instrumentation to generate a new application program; extracting log information through data flow analysis to match with an original execution sequence, constructing a reduce algorithm for filtering useless events by using the change characteristics of a UI (user interface), and performing first-step filtering on the execution sequence; on the basis, a program slicing technology is applied to extract a slicing dependency relationship, slicing analysis is carried out on a corresponding sequence of the crash, so that a sequence of necessary events is generated, on the basis of a spanning tree algorithm of the second step of reduction, the length and the sequence of the reduced sequence are optimized by using the necessary events, and finally a minimum execution sequence is generated. The invention aims to solve the problems of the prior mobile application that the execution sequence reduction precision and time are optimized, further help the mobile tester to obtain the effective simplest sequence result in limited time, help the mobile tester to make a reasonable scheme and strategy for solving the abnormity, and finally achieve the purposes of improving the software testing efficiency and guaranteeing the software quality.
Description
Technical Field
The invention belongs to the field of software testing and program analysis, is particularly suitable for the field of safety and reliability of a test program in mobile testing, aims to provide guidance for mobile testing personnel to carry out abnormal testing in an application development environment, and provides a method for helping the mobile testing personnel to determine the defects of application software and locate problem codes within a limited time.
Background
In recent years, the mobile internet industry has seen explosive growth. The number and complexity of mobile applications is rapidly increasing. According to data statistics, the Android OS accounts for 87.8% of smartphone market share in the third quarter of 2016. In Google Play, Android applications exceed 260 million. In order to improve the satisfaction of the end-user, mobile application developers must improve the quality of their applications, and mobile testing is an important measure to achieve this goal. Different kinds of testing techniques have been proposed to test Android applications, including fuzz testing, GUI traversal-based testing, and search-based testing. Fuzzy testing is represented by the Monkey tool family, including Android OS built-in Monkey tools and third party modified versions thereof. Due to the characteristics of simplicity, effectiveness and wide applicability, the improved Monkey tool is widely adopted by the cloud-based mobile test platform.
Existing Android testing tools (e.g., Monkey) generate a large variety of user events to expose potential exceptions and errors in Android applications. However, even if a crash is found, most of the events that result therefrom are often redundant or unrelated to the crash. In addition, it is also difficult for a developer to locate and reproduce the crash if a large length of event sequence (script) is given.
One major limitation of these fuzz testing techniques is that they typically generate a large number of input events before a failure is triggered, which makes subsequent debugging tasks difficult to apply. In this case, it is necessary to simplify the sequence of input events that trigger the same fault, and in order to ensure the quality of the Android application, many automatic test case generation techniques have been proposed. Wherein, the Monkey fuzz testing tool and the variety thereof are simple, effective and wide in application range. However, one major drawback of these Monkey tools is that they often generate many events in the input trace that cause the fault, which makes subsequent debugging activities difficult to apply. Therefore, simplification of the execution sequence for creating crash is necessary.
Before that, there have been some groups and individuals working on fuzz testing techniques, in the process of executing sequence reduction, the possibility of difference generated by testing tools needs to develop good standards to distinguish the side effects of events so as to eliminate redundant events driven by triggered errors. The Echo tool has the defects that the detected result crash has low recurrence rate, and the partial execution sequence cannot reach the simplest reduced sequence.
In view of the above, the present invention provides a method for reducing a sequence of execution of a context-based mobile application. The basic idea of the invention is as follows: aiming at an input event sequence with a fault in android application, firstly, using a static analysis technology, aiming at a specified package, calling all methods in the specified package, inserting log output statements comprising resource row numbers, class names, method names, Jimple statements and method callback fields through socket instrumentation, and generating a new application program; extracting log information through data flow analysis to match with an original execution sequence, constructing a reduce algorithm for filtering useless events by using the change characteristics of a UI (user interface), and performing first-step filtering on the execution sequence; on the basis, a program slicing technology is applied to extract a slicing dependency relationship, slicing analysis is carried out on a corresponding sequence of the crash, so that a sequence of necessary events is generated, on the basis of a spanning tree algorithm of the second step of reduction, the length and the sequence of the reduced sequence are optimized by using the necessary events, and finally a minimum execution sequence is generated.
By the method, the mobile tester can be helped to reduce the number of the execution events triggering the crash in a short time, further determine the reasons of the defects, locate the positions of error codes, reduce the decision time of the tester, and help developers and maintainers to indicate directions, so that the mobile test and software research and development efficiency is effectively improved.
Disclosure of Invention
The invention provides a context-based mobile application execution sequence reduction method, which effectively solves the problems of the precision and the time of executing sequence reduction on the existing mobile application, further helps mobile testers to obtain an effective simplest sequence result within limited time, and helps the mobile testers to formulate a reasonable scheme and strategy for solving the abnormity.
In order to achieve the aim, the invention provides a mobile application execution sequence reduction method based on context, aiming at an execution sequence with abnormal or error reporting of an android application, firstly, a static analysis technology is used, an application program capable of outputting logs is generated through socket instrumentation, log information is extracted through data flow analysis and matched with an original execution sequence, a reduce algorithm for filtering useless events is constructed in an auxiliary mode through the change characteristics of a UI (user interface), the execution sequence is filtered in the first step, on the basis, a program slicing technology is applied, slicing dependency relation extraction is achieved, a corresponding sequence of crash is subjected to slicing analysis, a sequence of necessary events is generated, on the basis of a tree generation algorithm in the second step, the length and the sequence of a reduced sequence are optimized through the necessary events, and the minimum execution sequence is generated finally. Specifically, the method comprises the following steps.
1) socket instrumentation, which is used for statically analyzing an application program, appointing a specific main package to eliminate the influence of method invocation of other classes, adding log statements in a code line for all method invocation lines InvokeStmt, wherein tag is output, value contains Java resource line number Java source line number, class name, method name and Jimple statement representation, if the method CALLBACK is, adding a CALLBACK field, and automatically signing the application program by using a cmd command after the instrumentation;
the purpose of this step is to add output statements in the application program, save the basic information of the method and the dependency information between the methods, and provide data support for the subsequent first-step filtering, so that the corresponding relation with the sequence is completed when the execution sequence is run, and the useless events, that is, the events which do not affect the last abnormal state in the running of the execution sequence, help the judgment of the useless events through the analysis of the data stream.
2) And sequence filtering, namely running an original execution sequence on the application program after the instrumentation, capturing log information through a thread, synchronously outputting the log information and the execution sequence, judging that the execution sequence contains useless events if the events are followed by no method call and the xml information of pages before and after the execution events is not changed, storing data usefruscript, filtering the useless events, generating a new script log and an execute log, executing the new sequence on the application program, and indicating that the first-step filtering is successful if the crash can be reproduced.
3) Program slicing, after performing root instrumentation on a program, collecting log information with a specific label generated in runtime, and constructing a valid PDG (program dependency graph), wherein the construction of the graph needs to execute a static analysis on demand after the execution, the range is narrowed to an application program part executed only in the runtime, then a program statement causing the creation of crash is found according to the crash information, the execution log of the statement is used as a slicing standard, then the log information of the application program is analyzed, and a specific execution PDG is generated according to the slicing standard, the PDG is constructed by gradually adding nodes and edges by backward exploring the dependency relationship, wherein the dependency of the PDG comprises four parts: synchronous and asynchronous data dependence, synchronous and asynchronous control dependence, and finally acquiring a script sequence which has influence on generating crash according to the corresponding relation between the script event and the execution statement log in the PDG.
4) Generating tree reduction, wherein a HDD algorithm (HDD algorithm) is used in the step, a GUI state Hierarchical tree is required to be formed according to GUI information before the algorithm is used, the tree uses the Hierarchical relationship of the GUI state to express the Hierarchical relationship of events corresponding to the GUI state, nodes are formed by the current GUI state and the events needing to be executed, edges express the parent-child relationship between the two GUI states, then the HDD algorithm is used for reducing the Hierarchical tree, the reduced event sequence is executed after each reduction, the next reduction is carried out according to whether crash is generated, and the final event sequence is obtained after the reduction of the algorithm is finished.
Further, the specific steps of the step 1) are as follows:
step 1) -1: an initial state;
step 1) -2: inputting an application program to be tested;
step 1) -3: creating a ProcessManifest object, and analyzing the PackageName of the application program;
step 1) -4: initializing a root tool and setting parameters;
step 1) -5: analyzing the application program, and converting the application program into a jimple statement by using a root tool;
step 1) -6: acquiring all units in the body, and forcibly converting the units into stmt;
step 1) -7: specifying a specific package and a specific sentence of the instrumentation;
step 1) -8: creating toastUnits, and setting tag and value values of output logs;
step 1) -9: inserting a Toast message after each jimple statement;
step 1) -10: the socket tool realizes automatic pile insertion and generates a new application program;
step 1) -11: generating a keystore signature tool, and executing a signature script automatic signature application program by using cmd;
step 1) -12: outputting the application program after the instrumentation and the signature;
step 1) -13: and ending the state.
Further, the specific steps of the step 2) are as follows:
step 2) -1: an initial state;
step 2) -2: inputting an original execution sequence script;
step 2) -3: initializing application program information, and starting a virtual machine to connect with an Apdium tool;
step 2) -4: the Apium automatically installs the application program after the pile insertion;
step 2) -5: running an original execution sequence script by using an Apdium tool, and recording and counting UI changes before and after each event;
step 2) -6: creating a capturing logcat thread, and outputting the executed events to a log in real time;
step 2) -7: judging a useless event according to the log information and the UI change information;
step 2) -8: filtering useless events in the original sequence to generate a new execution sequence;
step 2) -9: running a new execution sequence on the application program, and if the crash can be reproduced, successfully filtering;
step 2) -10: outputting a new execution sequence script, an execute file and a filtering result file;
step 2) -11: and ending the state.
Further, the specific steps of the step 3) are as follows:
step 3) -1: an initial state;
step 3) -2: inputting application program paths and script execution log information after pile insertion;
step 3) -3: initializing application program information, and starting a virtual machine to connect with an Apdium tool;
step 3) -4: running the original execution sequence script by utilizing an Apdium tool;
step 3) -5: acquiring all units in the body, and comparing the units with execution log information;
step 3) -6: storing the unit corresponding to the log information and outputting the unit to a file;
step 3) -7: determining a slicing standard according to the output result;
step 3) -8: searching other units with dependency relationship among the stored units according to the slicing standard;
step 3) -9: adding the found unit into the PDG, and continuously searching the unit which has a dependency relationship with the unit in the PDG;
step 3) -10: the PDG finishes searching without any dependency relation with the outside;
step 3) -11: searching for a scirpt event which has a corresponding relation with a unit in the PDG;
step 3) -12: outputting a corresponding event sequence;
step 3) -13: and ending the state.
Further, the specific steps of the step 4) are as follows:
step 4) -1: an initial state;
step 4) -2: inputting an original execution sequence script and state information;
step 4) -3: initializing application program information, and starting a virtual machine to connect with an Apdium tool;
step 4) -4: constructing a GUI hierarchical state tree according to the script and the state information;
step 4) -5: performing HDD reduction on the GUI hierarchical state tree and generating a corresponding execution script;
step 4) -6: executing the script after reduction, and recording the running state information;
step 4) -7: judging whether reduction is needed according to the latest script and the state information, if so, executing the steps 4) -4 according to the previous operation result, otherwise, executing the steps 4) -8;
step 4) -8: outputting a final simplest reduction result;
step 4) -9: and ending the state.
Drawings
FIG. 1 is a flow chart of a context-based mobile application execution sequence reduction method in accordance with an embodiment of the present invention.
Fig. 2 is a flow chart of the root stake insertion of fig. 1.
FIG. 3 is a flow chart of the sequence filtering of FIG. 1.
Fig. 4 is a flow chart of the program slice of fig. 1.
FIG. 5 is a flow chart of spanning tree reduction of FIG. 1.
Detailed Description
In order to better understand the technical content of the present invention, specific embodiments are described below with reference to the accompanying drawings.
FIG. 1 is a flow chart of a context-based mobile application execution sequence reduction method implemented in accordance with the present invention.
The method for reducing the execution sequence of the context-based mobile application is characterized by comprising the following steps.
S1, socket pile inserting, inputting an application program to be tested, analyzing a PackageName of the application program, and designating the package of the pile inserting; initializing a root tool, setting parameters, and inserting log output statements after all methods are called; new applications are instrumented and signed using the root tool.
S2, filtering the sequence, and inputting an original execution sequence script; initializing application program information, and starting a virtual machine to connect with an Apdium tool; installing a new application program to the virtual machine by using an Apdium tool, running an original execution sequence script, and recording and counting UI changes before and after each event; creating a capturing logcat thread, and outputting the executed events to a log in real time; and judging useless events according to the log information and the UI change information, and filtering the original sequence to generate a new sequence.
S3 program slicing, inputting application program path and script execution log information; using a root tool to obtain unit information in the body, and comparing the unit information with an execution log; storing and outputting the unit which has a contrast relation with the log; determining a slicing standard according to the output result; searching other units with dependency relationship based on the slicing standard and adding the units into PDG; continuously searching a unit with a dependency relationship with the PDG and adding the unit until the PDG has no dependency relationship with the outside; searching a script event which has a corresponding relation with the unit in the PDG; and outputting the final script event.
S4 generating tree reduction, inputting original execution sequence script and state information; initializing application program information, and starting a virtual machine to connect with an Apdium tool; constructing a GUI hierarchical state tree according to the script and the state information; performing HDD algorithm reduction on the GUI hierarchical state tree and generating a corresponding event script; executing the event script and recording corresponding state information; according to the execution result, carrying out next reduction of the HDD algorithm until the reduction can not be carried out any more; and outputting a final reduction result.
Fig. 2 is a flow chart of root stake insertion. The method comprises the steps of carrying out static analysis on an application program, designating a specific main package to eliminate the influence of method calling of other classes, and adding log output statements in a code line for all method calling lines, wherein tag is output, value comprises a java resource line number, a class name, a method name and a Jimple statement, a method callback field, and automatically signing the application program by using a cmd command after instrumentation. The method comprises the following specific steps:
step 1: an initial state; step 2: inputting an application program to be tested; and step 3: creating a ProcessManifest object, and analyzing the PackageName of the application program; and 4, step 4: initializing a root tool and setting parameters; and 5: analyzing the application program, and converting the application program into a jimple statement by using a root tool; step 6: acquiring all units in the body, and forcibly converting the units into stmt; and 7: specifying a specific package and a specific sentence of the instrumentation; and 8: creating toastUnits, and setting tag and value values of output logs; and step 9: inserting a Toast message after each jimple statement; step 10: the socket tool realizes automatic pile insertion and generates a new application program; step 11: generating a keystore signature tool, and executing a signature script automatic signature application program by using cmd; step 12: outputting the application program after the instrumentation and the signature; step 13: and ending the state.
Fig. 3 is a flow chart of feature selection. And running an original execution sequence on the application program after the instrumentation, capturing log information through a thread, synchronously outputting the log information and the execution sequence, judging that the event is a useless event if no method is called after the event and the xml information of the page before and after the execution event is not changed, so that the execution sequence contains the useless events, filtering the useless events, and executing a new sequence on the application program, so that crash can be reproduced. The method comprises the following specific steps:
step 1: an initial state; step 2: inputting an original execution sequence script; and step 3: initializing application program information, and starting a virtual machine to connect with an Apdium tool; and 4, step 4: the Apium automatically installs the application program after the pile insertion; and 5: running an original execution sequence script by using an Apdium tool, and recording and counting UI changes before and after each event; step 6: creating a capturing logcat thread, and outputting the executed events to a log in real time; and 7: judging a useless event according to the log information and the UI change information; and 8: filtering useless events in the original sequence to generate a new execution sequence; and step 9: running a new execution sequence on the application program, and if the crash can be reproduced, successfully filtering; step 10: outputting a new execution sequence script, an execute file and a filtering result file; step 11: and ending the state.
Fig. 4 is a flow chart of program slicing. After the program is subjected to socket instrumentation, collecting log information with a specific label generated in the runtime, finding a program statement causing the creation of the crash according to the crash information, taking an execution log of the statement as a slicing standard, analyzing the log information of the application program, generating a specific execution PDG according to the slicing standard, and finally acquiring a script sequence influencing the creation of the crash according to the corresponding relation between a script event and the execution statement log in the PDG. The method comprises the following specific steps:
step 1: an initial state; step 2: inputting application program paths and script execution log information after pile insertion; and step 3: initializing application program information, and starting a virtual machine to connect with an Apdium tool; and 4, step 4: running the original execution sequence script by utilizing an Apdium tool; and 5: acquiring all units in the body, and comparing the units with execution log information; step 6: storing the unit corresponding to the log information and outputting the unit to a file; and 7: determining a slicing standard according to the output result; and 8: searching other units with dependency relationship among the stored units according to the slicing standard; and step 9: adding the found unit into the PDG, and continuously searching the unit which has a dependency relationship with the unit in the PDG; step 10: the PDG finishes searching without any dependency relation with the outside; step 11: searching for a scirpt event which has a corresponding relation with a unit in the PDG; step 12: outputting a corresponding event sequence; step 13: an end state;
FIG. 5 is a flow chart of spanning tree reduction. And constructing a GUI state hierarchical tree according to GUI information, wherein the tree uses the hierarchical relationship of GUI states to express the hierarchical relationship of events corresponding to the GUI states, nodes are composed of the current GUI state and the events needing to be executed, edges express the parent-child relationship between the two GUI states, then the hierarchical tree is reduced by using an HDD algorithm, the event sequence of reduction is executed after each reduction, the next reduction is carried out according to whether crash is generated, and the final event sequence is obtained after the reduction of the algorithm is finished. The method comprises the following specific steps:
step 1: an initial state; step 2: inputting an original execution sequence script and state information; and step 3: initializing application program information, and starting a virtual machine to connect with an Apdium tool; and 4, step 4: constructing a GUI hierarchical state tree according to the script and the state information; and 5: performing HDD reduction on the GUI hierarchical state tree and generating a corresponding execution script; step 6: executing the script after reduction, and recording the running state information; and 7: judging whether reduction is needed according to the latest script and the state information, if so, executing the steps 4) -4 according to the previous operation result, otherwise, executing the steps 4) -8; and 8: outputting a final simplest reduction result; and step 9: an end state;
in summary, the invention solves the problems of the existing mobile application in executing the optimization of the sequence reduction precision and time, further helps the mobile tester to obtain the effective simplest sequence result in a limited time, helps the mobile tester to make a reasonable solution and strategy for solving the exception, and finally achieves the purposes of improving the software testing efficiency and guaranteeing the software quality.
Claims (5)
1. A mobile application execution sequence reduction method based on context is characterized in that for an execution sequence with abnormal or error reporting of an android application, firstly, a static analysis technology is used, an application program capable of outputting logs is generated through socket instrumentation, log information is extracted through data flow analysis and matched with an original execution sequence, a reduce algorithm for filtering useless events is established by using the change characteristics of a UI (user interface), the execution sequence is filtered in the first step, a program slicing technology is applied on the basis, extraction of slice dependency relationships is achieved, a corresponding sequence of crash is subjected to slice analysis, a sequence of necessary events is generated, on the basis of a tree generation algorithm reduced in the second step, the length and the sequence of the reduced sequence are optimized by using the necessary events, and a minimum execution sequence is generated finally; the method comprises the following steps:
1) socket instrumentation, which is used for statically analyzing an application program, appointing a specific main package to eliminate the influence of method invocation of other classes, adding log statements in a code line for all method invocation lines InvokeStmt, wherein tag is output, value contains Java resource line number Java source line number, class name, method name and Jimple statement representation, if the method CALLBACK is, adding a CALLBACK field, and automatically signing the application program by using a cmd command after the instrumentation;
the purpose of this step is to add output statement in the application program, save the basic information of the method and the dependency information among the methods, and provide data support for the subsequent first step of filtering, so that the corresponding relation with the sequence is completed when the execution sequence is run, and the useless event, that is, the event which does not affect the last abnormal state in the running of the execution sequence, helps the judgment of the useless event through the analysis of the data stream;
2) sequence filtering, namely running an original execution sequence on the application program after the instrumentation, capturing log information through a thread, synchronously outputting the log information and the execution sequence, judging that the execution sequence contains useless events if the events are followed by no method call and the xml information of pages before and after the execution events is not changed, storing data usefruscript, filtering the useless events, generating a new script log and an execute log, executing the new sequence on the application program, and indicating that the first-step filtering is successful if the crash can be reproduced;
3) program slicing, after performing root instrumentation on a program, collecting log information with a specific label generated in runtime, and constructing a valid PDG (program dependency graph), wherein the construction of the graph needs to execute a static analysis on demand after the execution, the range is narrowed to an application program part executed only in the runtime, then a program statement causing the creation of crash is found according to the crash information, the execution log of the statement is used as a slicing standard, then the log information of the application program is analyzed, and a specific execution PDG is generated according to the slicing standard, the PDG is constructed by gradually adding nodes and edges by backward exploring the dependency relationship, wherein the dependency of the PDG comprises four parts: synchronous and asynchronous data dependence, synchronous and asynchronous control dependence, and finally acquiring a script sequence influencing the production of crash according to the corresponding relation between the script event and the execution statement log in the PDG;
4) generating tree reduction, wherein a HDD algorithm (HDD algorithm) is used in the step, a GUI state Hierarchical tree is required to be formed according to GUI information before the algorithm is used, the tree uses the Hierarchical relationship of the GUI state to express the Hierarchical relationship of events corresponding to the GUI state, nodes are formed by the current GUI state and the events needing to be executed, edges express the parent-child relationship between the two GUI states, then the HDD algorithm is used for reducing the Hierarchical tree, the reduced event sequence is executed after each reduction, the next reduction is carried out according to whether crash is generated, and the final event sequence is obtained after the reduction of the algorithm is finished.
2. The context-based mobile application execution sequence reduction method of claim 1, wherein in step 1), socket instrumentation is performed; the method comprises the steps of performing static analysis on an original application program, obtaining all units in Body, enabling one Body to correspond to a method Body of a method in Java, enabling Unit to represent statements in the Unit, converting the Unit into Stmt in a forced mode, enabling the Stmt to be the representation of each statement in Jimple, obtaining android.
3. The context-based mobile application execution sequence reduction method of claim 1, wherein in step 2), sequence filtering is performed; creating a log input stream through PrintStream, starting an execution sequence and outputting the log in real time, simultaneously creating a thread for capturing logcat, using the same PrintStream to generate an output log, judging whether to trigger method calling according to the relation between an event line and a method calling line, recording the name of an event by using an array, simultaneously recording the change of page xml information before and after each event, and filtering the event which does not generate the change and does not generate the method calling in an original sequence.
4. The context-based mobile application execution sequence reduction method of claim 1, wherein in step 3), program slicing is performed; the method comprises the steps of obtaining method information in the apk by instantiating a Slicer and using a root tool, enabling each statement in the method to correspond to one unit in Body, comparing the unit with statement logs generated in a running log, screening out units obtained and executed during running, determining a unit statement according to an input slicing standard, obtaining other statements having dependency relation with the statement according to additional information in usebox and intent in the statement on the basis of the unit statement, adding the other statements into a PDG, conducting dependency exploration on each statement in the PDG, enabling each statement in the PDG to have no dependency relation with the outside, and generating a final PDG, wherein each statement in the graph is a statement related to production of crash.
5. The method of claim 1, wherein in step 4), a spanning tree reduction is performed; when a GUI state hierarchical tree is generated, the algorithm constructs a new node for each state, then compares the new node with all previous nodes, if the node is the same as a certain previous node, the node is added as a peer node of the same node, otherwise, the node is added as a child node of the previous node, when the HDD algorithm is used for reduction, the algorithm reduces the nodes layer by layer from top to bottom, an intra-layer node reduction process inlevel _ HDD () is called in each layer, the method partitions an event sequence and checks the last partition, if the result is successful, the method is executed for the next layer of the partition by recursive reduction, otherwise, the remaining parts of other partitions are tried to be reduced by the recursive reduction, and if the result is still failed, the more refined level reduction is executed; in the HDD reduction process, checkEvent () is responsible for executing the event sequence, checking if a crash triggers.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111495962.5A CN114138662A (en) | 2021-12-09 | 2021-12-09 | Context-based mobile application execution sequence reduction method |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111495962.5A CN114138662A (en) | 2021-12-09 | 2021-12-09 | Context-based mobile application execution sequence reduction method |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN114138662A true CN114138662A (en) | 2022-03-04 |
Family
ID=80385133
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202111495962.5A Pending CN114138662A (en) | 2021-12-09 | 2021-12-09 | Context-based mobile application execution sequence reduction method |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN114138662A (en) |
-
2021
- 2021-12-09 CN CN202111495962.5A patent/CN114138662A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US8245194B2 (en) | Automatically generating unit test cases which can reproduce runtime problems | |
| US8966449B2 (en) | Test case pattern matching | |
| Sakti et al. | Instance generator and problem representation to improve object oriented code coverage | |
| Jin et al. | Automated behavioral regression testing | |
| US9535823B2 (en) | Method and apparatus for detecting software bugs | |
| CN110427331B (en) | Method for automatically generating performance test script based on interface test tool | |
| Soltani et al. | A guided genetic algorithm for automated crash reproduction | |
| US20020091968A1 (en) | Object-oriented data driven software GUI automated test harness | |
| US20070061641A1 (en) | Apparatus and method for generating test driver | |
| CN111459786A (en) | Intelligent contract security testing method based on variant fuzz | |
| CN107329889B (en) | Method for automatically testing C compiler | |
| Kifetew et al. | Reproducing field failures for programs with complex grammar-based input | |
| US9183122B2 (en) | Automated program testing to facilitate recreation of test failure | |
| CN112084108A (en) | Test script generation method and device and related components | |
| Barton et al. | Dynamic and graphical web page breakpoints | |
| CN114138662A (en) | Context-based mobile application execution sequence reduction method | |
| KR100777103B1 (en) | Apparatus and method for generation of test driver | |
| Insa et al. | Behaviour preservation across code versions in erlang | |
| Kruse | Test oracles and test script generation in combinatorial testing | |
| Singhal et al. | A critical review of various testing techniques in aspect-oriented software systems | |
| Saes | Unit test generation using machine learning | |
| CN110347589B (en) | Software unit test automatic detection method and system | |
| CN110795142B (en) | Configuration file generation method and device | |
| Abdi et al. | Test transplantation through dynamic test slicing | |
| Micskei et al. | Robustness testing techniques for high availability middleware solutions |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |