CN112882943A

CN112882943A - Interface updating collapse risk detection method and device, electronic equipment and storage medium

Info

Publication number: CN112882943A
Application number: CN202110265818.6A
Authority: CN
Inventors: 吴柳
Original assignee: Tencent Music Entertainment Technology Shenzhen Co Ltd
Current assignee: Tencent Music Entertainment Technology Shenzhen Co Ltd
Priority date: 2021-03-11
Filing date: 2021-03-11
Publication date: 2021-06-01

Abstract

The application discloses a method, a device and equipment for detecting interface update collapse risk and a computer readable storage medium, wherein the method comprises the following steps: acquiring a project code to be detected, and performing interface updating function detection on the project code to be detected to obtain a target interface updating function; updating a function based on the target interface, and generating function call relation information corresponding to the project code to be tested; taking each target interface updating function as a first end function, constructing a plurality of function chains by using function call relation information, and identifying a second end function corresponding to each function chain; if any second end function is a non-main thread function, determining that a target function chain to which the non-main thread function belongs has interface updating collapse risk; the method adopts a static test mode, can accurately and comprehensively identify the UI updating crash of the project code to be tested, can cover all detection scenes, and has good detection effect; and random detection is not needed, so the detection time is short, and the detection efficiency is high.

Description

Interface updating collapse risk detection method and device, electronic equipment and storage medium

Technical Field

The present disclosure relates to the field of software testing technologies, and in particular, to a method for detecting interface update crash risk, an apparatus for detecting interface update crash risk, an electronic device, and a computer-readable storage medium.

Background

An Interface update is also called a UI (User Interface) update crash, which is a software error caused by a child thread updating a UI. Whether the thread for updating the UI is the main thread or not is often changed along with the running of the program, the uncertainty is high, and in order to prevent the UI from updating the crash, an interface updating crash risk test is usually performed in the program testing process. The related art generally adopts a test tool such as monkey to generate and send a pseudo-random user event stream for dynamic test so as to find out UI update crash. However, the related technology cannot completely cover various detection scenes, and the detection effect is poor; and the required detection time is longer, and the detection efficiency is lower.

Disclosure of Invention

In view of this, an object of the present application is to provide an interface update crash risk detection method, an interface update crash risk detection apparatus, an electronic device, and a computer-readable storage medium, which can accurately and comprehensively detect whether a UI update crash risk exists in a to-be-detected item code by constructing a function chain and detecting whether an initial function of the function chain is a non-main thread function, and have high detection capability and efficiency.

In order to solve the foregoing technical problem, in a first aspect, the present application provides a method for detecting an interface update crash risk, including:

acquiring a project code to be detected, and performing interface updating function detection on the project code to be detected to obtain a target interface updating function;

generating function call relation information corresponding to the project code to be tested;

taking each target interface updating function as a first end function, constructing a plurality of function chains by using the function call relation information, and identifying a second end function corresponding to each function chain;

and if any second end function is a non-main thread function, determining that the target function chain to which the non-main thread function belongs has the risk of interface update breakdown.

In a possible implementation manner, the taking each target interface update function as a first end function, constructing a plurality of function chains by using the function call relation information, and identifying a second end function corresponding to each function chain includes:

determining a direct calling function corresponding to each target interface updating function by using the function calling relation information;

determining the direct calling function as a called function, and judging whether a superior function corresponding to the called function exists or not by using the function calling relation information;

if the superior function exists, determining the superior function as the called function;

and if the superior function does not exist, determining that the function chain is completely constructed, and determining the function to be established as the second end function.

In a possible implementation manner, the determining that the function chain is constructed if the superior function does not exist includes:

if the superior function does not exist, judging whether the called function has a corresponding target parent function or a target interface function by using the function call relation information;

if the target parent function or the target interface function exists, determining the target parent function or the target interface function as the called function;

and if the target parent function or the target interface function does not exist, determining that the function chain is completely constructed.

In a possible implementation manner, before performing interface update function detection on the item code to be detected, the method further includes:

screening each function by using an interface updating basic function, and determining the function calling the interface updating basic function as an interface updating function;

generating interface updating function detection data by using the function name corresponding to the interface updating function;

correspondingly, the interface update function detection on the item code to be detected to obtain a target interface update function includes:

performing function name matching on each function to be tested in the project codes to be tested by using the interface updating function detection data;

and determining the function to be tested matched with the function name as the target interface updating function.

In a possible implementation manner, the generating function call relationship information corresponding to the item code to be tested includes:

acquiring a detection plug-in and corresponding detection plug-in information;

and adding the detection plug-in information into the item code to be detected, compiling the item code, and calling the detection plug-in the compiling process to obtain the function calling relation information.

In a possible embodiment, the method further comprises:

generating a detection result by using the objective function chain;

and acquiring executor information corresponding to the item code to be detected, and feeding back the detection result by using the executor information.

In a possible embodiment, the method further comprises:

acquiring call-free function information, and marking a function corresponding to the call-free function information in the item code to be tested as a call-free function;

correspondingly, if any of the second end functions is a non-main thread function, determining that the objective function chain to which the non-main thread function belongs has an interface update collapse risk, including:

if any second end function is a non-main thread function, judging whether the non-main thread function is the call-free function;

and if any non-main thread function is not the call-free function, determining that the target function chain has the risk of interface update crash.

In a second aspect, the present application further provides an interface update crash risk detection apparatus, including:

the updating function detection module is used for acquiring a project code to be detected and carrying out interface updating function detection on the project code to be detected to obtain a target interface updating function;

the function call relation information generating module is used for generating function call relation information corresponding to the project code to be detected;

the function chain construction module is used for taking each target interface updating function as a first end function, constructing a plurality of function chains by using the function call relation information, and identifying a second end function corresponding to each function chain;

and the risk detection module is used for determining that the target function chain to which the non-main thread function belongs has interface updating collapse risk if any second end function is the non-main thread function.

In a third aspect, the present application further provides an electronic device, comprising a memory and a processor, wherein:

the memory is used for storing a computer program;

the processor is used for executing the computer program to realize the interface update crash risk detection method.

In a fourth aspect, the present application further provides a computer-readable storage medium for storing a computer program, where the computer program, when executed by a processor, implements the interface update crash risk detection method described above.

According to the interface updating collapse risk detection method, a project code to be detected is obtained, and interface updating function detection is carried out on the project code to be detected, so that a target interface updating function is obtained; updating a function based on the target interface, and generating function call relation information corresponding to the project code to be tested; taking each target interface updating function as a first end function, constructing a plurality of function chains by using function call relation information, and identifying a second end function corresponding to each function chain; and if any second end function is a non-main thread function, determining that the objective function chain to which the non-main thread function belongs has the risk of interface update breakdown.

Therefore, when the method is used for testing the project code to be tested, the target interface updating function is firstly identified, and the target interface updating function is a function which can cause UI updating in the project code to be tested. And after the target interface updating function is obtained, generating function calling relation information based on the target interface updating function. The function call relation information records the call relations among all functions in the item code to be tested, so that the function call relation information can be used for screening and obtaining the call relations among all functions related to the target interface updating function in the item code to be tested. And taking the target interface updating function as a first end function, and taking the function corresponding to the other end of the function chain as a second end function. If the second end function is a non-main thread function, it indicates that the second end function is not a function which can only be called by the main thread, and may be called by the sub-thread, and the sub-thread calling the second end function may cause the sub-thread to update the UI, so that there is a risk of UI updating crash, that is, it is determined that the target function chain to which the second end function belongs has a risk of interface updating collapse. The method adopts a static test mode, can accurately and comprehensively identify the UI updating crash of the project code to be detected, can cover all detection scenes, and has a good detection effect. And random detection is not needed, so that the detection time is short, the detection efficiency is high, and the problems of poor test effect and low test efficiency in the related technology are solved.

In addition, the application also provides an interface updating crash risk detection device, electronic equipment and a computer readable storage medium, and the device, the electronic equipment and the computer readable storage medium also have the beneficial effects.

Drawings

In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, the drawings needed to be used in the description of the embodiments or the prior art will be briefly introduced below, it is obvious that the drawings in the following description are only embodiments of the present application, and for those skilled in the art, other drawings can be obtained according to the provided drawings without creative efforts.

Fig. 1 is a schematic diagram of a hardware composition framework applicable to the interface update crash risk detection method according to the embodiment of the present application;

fig. 2 is a schematic diagram of a hardware composition framework applicable to another interface update crash risk detection method according to an embodiment of the present application;

fig. 3 is a schematic flowchart of a method for detecting a risk of interface update crash according to an embodiment of the present disclosure;

fig. 4 is a diagram of a call relationship of an interface update basic function according to an embodiment of the present application;

fig. 5 is a schematic structural diagram of an interface update crash risk detection apparatus according to an embodiment of the present disclosure.

Detailed Description

In order to make the objects, technical solutions and advantages of the embodiments of the present application clearer, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application, and it is obvious that the described embodiments are only a part of the embodiments of the present application, and not all the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present application.

The interface update crash, namely UI update crash, is a software error caused by updating the UI interface by a child thread, and because the software project code is complex, and whether the thread updating the UI is the main thread changes with the software running, the uncertainty of whether UI update crash occurs is high. In order to detect the crash, in the related art, an automatic test tool such as a monkey test tool and the like including thread interference is generally adopted, a random event stream is generated when software runs, a randomness test is further performed, and the occurred UI update crash is captured in the test process. However, the random test is time consuming and inefficient. All operations capable of updating the UI cannot be covered, that is, all detection scenes cannot be covered, meanwhile, the adoption of a thread interference mode cannot guarantee that the thread updating the UI is a sub-thread inevitably, and the detection reliability cannot be guaranteed, so that the detection effect is poor. In order to solve the problems, the method generates function call relation information corresponding to the item code to be tested, constructs a function chain by using the function call relation information, judges whether the function chain is possibly called by a sub-thread by judging whether a second end function in the function chain is a non-main thread function, and leads UI (user interface) to be updated when the sub-thread calls the function chain, so that UI updating crash occurs. Therefore, when the second end function is a non-main thread function, the UI updating crash is possible to occur, and therefore the interface updating crash risk is determined to be detected. According to the method, the problem discovery stage is advanced from the software running stage to the software compiling stage, and meanwhile, all function chains of the project codes to be detected are constructed, so that the comprehensive detection of the CRash risk of updating the UI is realized, the detection accuracy is improved, and the detection effect is better. Meanwhile, random detection is not needed, so that the detection time is short, and the detection efficiency is high.

For convenience of understanding, a hardware composition framework used in a scheme corresponding to the interface update crash risk detection method provided in the embodiment of the present application is introduced first. Referring to fig. 1, fig. 1 is a schematic diagram of a hardware composition framework applicable to the interface update crash risk detection method according to an embodiment of the present disclosure. Wherein the electronic device 100 may include a processor 101 and a memory 102, and may further include one or more of a multimedia component 103, an information input/information output (I/O) interface 104, and a communication component 105.

The processor 101 is configured to control overall operations of the electronic device 100 to complete all or part of the steps in the interface update crash risk detection method; the memory 102 is used to store various types of data to support operation at the electronic device 100, such data may include, for example, instructions for any application or method operating on the electronic device 100, as well as application-related data. The Memory 102 may be implemented by any type or combination of volatile and non-volatile Memory devices, such as one or more of Static Random Access Memory (SRAM), Electrically Erasable Programmable Read-Only Memory (EEPROM), Erasable Programmable Read-Only Memory (EPROM), Programmable Read-Only Memory (PROM), Read-Only Memory (ROM), magnetic Memory, flash Memory, magnetic or optical disk. In the present embodiment, the memory 102 stores therein at least programs and/or data for realizing the following functions:

updating a function based on the target interface, and generating function call relation information corresponding to the project code to be tested;

taking each target interface updating function as a first end function, constructing a plurality of function chains by using function call relation information, and identifying a second end function corresponding to each function chain;

and if any second end function is a non-main thread function, determining that the objective function chain to which the non-main thread function belongs has the risk of interface update breakdown.

The multimedia component 103 may include a screen and an audio component. Wherein the screen may be, for example, a touch screen and the audio component is used for outputting and/or inputting audio signals. For example, the audio component may include a microphone for receiving external audio signals. The received audio signal may further be stored in the memory 102 or transmitted through the communication component 105. The audio assembly also includes at least one speaker for outputting audio signals. The I/O interface 104 provides an interface between the processor 101 and other interface modules, such as a keyboard, mouse, buttons, etc. These buttons may be virtual buttons or physical buttons. The communication component 105 is used for wired or wireless communication between the electronic device 100 and other devices. Wireless Communication, such as Wi-Fi, bluetooth, Near Field Communication (NFC), 2G, 3G, or 4G, or a combination of one or more of them, so that the corresponding Communication component 105 may include: Wi-Fi part, Bluetooth part, NFC part.

The electronic Device 100 may be implemented by one or more Application Specific Integrated Circuits (ASICs), Digital Signal Processors (DSPs), Digital Signal Processing Devices (DSPDs), Programmable Logic Devices (PLDs), Field Programmable Gate Arrays (FPGAs), controllers, microcontrollers, microprocessors, or other electronic components for performing the interface crash update risk detection method.

Of course, the structure of the electronic device 100 shown in fig. 1 does not constitute a limitation of the electronic device in the embodiment of the present application, and in practical applications, the electronic device 100 may include more or less components than those shown in fig. 1, or some components may be combined.

It can be understood that, in the embodiment of the present application, the number of the electronic devices is not limited, and it may be a method for detecting a crash risk of a plurality of electronic devices cooperating together to complete interface update. In a possible implementation manner, please refer to fig. 2, and fig. 2 is a schematic diagram of a hardware composition framework applicable to another interface update crash risk detection method provided in the embodiment of the present application. As can be seen from fig. 2, the hardware composition framework may include: the first electronic device 11 and the second electronic device 12 are connected to each other through a network 13.

In the embodiment of the present application, the hardware structures of the first electronic device 11 and the second electronic device 12 may refer to the electronic device 100 in fig. 1. That is, it can be understood that there are two electronic devices 100 in the present embodiment, and the two devices perform data interaction. Further, in this embodiment of the application, the form of the network 13 is not limited, that is, the network 13 may be a wireless network (e.g., WIFI, bluetooth, etc.), or may be a wired network.

The first electronic device 11 and the second electronic device 12 may be the same electronic device, for example, the first electronic device 11 and the second electronic device 12 are both servers; or may be different types of electronic devices, for example, the first electronic device 11 may be a computer and the second electronic device 12 may be a server. In a possible embodiment, a server with high computing power may be used as the second electronic device 12 to improve the data processing efficiency and reliability, and further improve the processing efficiency of the interface update crash risk detection. Meanwhile, a computer with low cost and wide application range is used as the first electronic device 11 to realize the interaction between the second electronic device 12 and the user. It is to be understood that the interaction process may be: and the computer acquires the project code to be detected and performs interface updating function detection on the project code to be detected to obtain a target interface updating function. And the computer sends the project code to be tested and the target interface updating function to the server, and the server executes the subsequent steps until the interface updating collapse risk detection of the project code to be tested is completed.

Based on the above description, please refer to fig. 3, and fig. 3 is a schematic flowchart of a method for detecting a risk of interface update crash according to an embodiment of the present disclosure. The method in this embodiment comprises:

s101: and acquiring a project code to be detected, and performing interface updating function detection on the project code to be detected to obtain a target interface updating function.

The item code to be detected is a code for UI updating crash risk detection, and the specific content is not limited. The embodiment does not limit the specific obtaining manner of the item code to be detected, for example, in an embodiment, the item code to be detected may be obtained under a specified path, and the specified path may be preset, or may be input by a user, or may be sent by other electronic devices. In another embodiment, the communication interface with some electronic devices can be monitored, and the data transmitted by the communication interface can be determined as the item code to be tested. The embodiment does not limit the specific type, application scenario, specific number, and the like of the to-be-tested item code, and for example, a plurality of to-be-tested item codes corresponding to android APPs applied to a smart phone may be obtained at a time. After the item code to be detected is obtained, the interface updating function in the item code to be detected is detected to obtain a corresponding detection result, namely a target interface updating function, so that the target interface updating function is the interface updating function in the code to be detected. It should be noted that the interface update function in this embodiment is a function that causes the interface to be updated, and may include a function that directly updates the interface, or may include a function that directly calls, where the function that directly calls is a function that directly calls the function that updates the interface.

The embodiment does not limit a specific detection method for detecting the interface update function of the item code to be detected, for example, in a feasible implementation, the function content of the interface update function may be used to match the item code to be detected, and when the matching is successful, the target interface update function is determined to be detected. In another embodiment, since the function is usually used by calling the function in the code, the content of the function is not rewritten, the function name of the code can be used to match the item code to be tested, and when the matching is successful, the target interface update function is determined to be detected.

S102: and updating the function based on the target interface, and generating function call relation information corresponding to the project code to be tested.

After the target interface updating function is detected, it can be determined that the item code to be tested can perform UI updating in the execution process, and in order to determine whether the function for UI updating is called by the main thread, that is, whether the UI updating operation is executed by the main thread, it is also necessary to determine the calling relationship between the functions, so as to construct a function chain. The target interface updating function may be called through multiple layers, that is, there are other function calls to the function calling the target interface updating function, for example, when the a function is the target interface updating function, the a function is called by the B function, and the B function is called by the C function and the D function. Therefore, the function chain may be composed of a plurality of single links, each of which is used to represent a call relationship between a function and an upper function or a lower function that calls the function. The generated function call relation information may be a single-link function relation, that is, each information item in the function call relation information records a relation between a certain function and a corresponding upper function, or records a relation between a certain function and a lower function called by the function. The function call relation information records call relations among all functions in the item code to be tested, wherein a superior function which directly calls the target interface updating function is necessarily recorded, so that the function call relation information can be used for generating a function chain corresponding to the target interface updating function. The embodiment does not limit the specific form of the function-call relationship information, and for example, the function-call relationship information may include a plurality of pieces of sub information, each piece of sub information having a plurality of information items recorded therein, and the information items recorded in different pieces of sub information are different. For example, in one embodiment, the method may include two pieces of sub information, namely, a method and a viewmethod, where an information item in the viewmethod records a relationship between each target interface update function and a direct call function that directly calls the target interface update function, and the method records a correspondence relationship existing between all functions in the item code to be tested.

The embodiment does not limit the specific manner of generating the function call relationship information, for example, in a feasible implementation manner, the function call relationship information may be acquired by using an AST (Abstract Syntax Tree) scheme; in another embodiment, the function call relationship information may be obtained by using an AOP (Aspect organized Programming) scheme; in another embodiment, a static inverse disassembling scheme may be adopted to obtain function call relation information; in another embodiment, the function call relation information may be obtained by using an ASM (Java bytecode manipulation framework, which may be used to dynamically generate classes or enhance the functions of existing classes) scheme. According to different application modes, the specific process of acquiring the function call relationship information is also different, and reference may be made to related technologies specifically, which is not described herein in detail in this embodiment.

S103: and taking each target interface updating function as a first end function, constructing a plurality of function chains by using the function calling relation information, and identifying a second end function corresponding to each function chain.

After the function call relation information is obtained, each target interface updating function is used as a first end function, namely, a first end point of the function chain, the call relation among all functions in the project code to be tested is determined according to the function call relation information, and the function chain is constructed according to the call relation. After the function chain is built, the function on the other end point of the function chain is determined as a second end function, and the second end function is the most basic function for calling the update function of the target interface and is also the most basic function for causing the UI to be updated.

The embodiment does not limit the specific construction manner of the function chain, for example, a direct call function corresponding to the target interface update function may be determined, and whether the direct call function is called is determined by using the function call relationship, if the direct call function is called, a superior function corresponding to the direct call function is determined, and whether the superior function is called is further determined, until a function that is not called is detected, the function is the second end function.

S104: and if any second end function is a non-main thread function, determining that the objective function chain to which the non-main thread function belongs has the risk of interface update breakdown.

It should be noted that the main thread function is a function that can only be called by the main thread, and therefore the non-main thread function is a function that can be called by the non-main thread (i.e., the sub-thread), and the specific number and content thereof are not limited. After the function chains are constructed, each function chain is provided with a corresponding second end function, if any second end function is a non-main thread function, the function can be called by a sub-thread, the function is inevitably updated by calling the function, and if the second end function is called by the sub-thread, the UI is updated by calling the sub-thread. Therefore, when any second end function is a non-main thread function, the risk of updating crash by the UI is shown, and the objective function chain to which the second end function belongs is determined to have the risk of crashing the interface update, namely the risk of updating crash by the UI.

By applying the interface updating collapse risk detection method provided by the embodiment of the application, when the project code to be tested is tested, the target interface updating function is firstly identified, and the target interface updating function is a function which can cause UI updating in the project code to be tested. And after the target interface updating function is obtained, generating function calling relation information based on the target interface updating function. The function call relation information records the call relations among all functions in the item code to be tested, so that the function call relation information can be used for screening and obtaining the call relations among all functions related to the target interface updating function in the item code to be tested. And taking the target interface updating function as a first end function, and taking the function corresponding to the other end of the function chain as a second end function. If the second end function is a non-main thread function, it indicates that the second end function is not a function which can only be called by the main thread, and may be called by the sub-thread, and the sub-thread calling the second end function may cause the sub-thread to update the UI, so that there is a risk of UI updating crash, that is, it is determined that the target function chain to which the second end function belongs has a risk of interface updating collapse. The method adopts a static test mode, can accurately and comprehensively identify the UI updating crash of the project code to be detected, can cover all detection scenes, and has a good detection effect. And random detection is not needed, so that the detection time is short, the detection efficiency is high, and the problems of poor test effect and low test efficiency in the related technology are solved.

Based on the above embodiments, the present embodiment specifically describes some steps in the above embodiments. In a specific embodiment, before detecting the target interface update function in the project code to be tested, it needs to determine which functions are interface update functions. Therefore, before the interface update function detection is performed on the item code to be detected, the following steps may be further included:

step 11: and screening each function by using the interface updating basic function, and determining the function calling the interface updating basic function as the interface updating function.

The interface updating basic function is a function for updating the page, namely a function for directly updating the interface, which is a lowest-level function. According to the difference of the code types corresponding to the project codes to be tested, the contents of the interface updating basic functions can be different, and the number of the page updating basic functions corresponding to each code type can be one or more. In other embodiments, the page update basis function may be directly used as the interface update function. In the embodiment, since the project code to be tested is usually constructed by using a fixed level function as a basic function, the basic function is usually not a lowest level function, but is constructed by calling a function lower than the level thereof, which necessarily includes the lowest level function. Therefore, the interface updating basic function cannot be directly used as the interface updating function, because the interface updating basic function does not exist in the project code to be tested. In this case, it is necessary to filter each basic function by using the interface update basic function, specifically, filter the function content of each basic function, and determine the basic function having the interface update function as the interface update function.

Taking Java programming language as an example, please refer to fig. 4, and fig. 4 is a diagram of an interface update basic function call relation provided in an embodiment of the present application. When updating the UI, it is necessary to call the checkThread function in the underlying view rootimpl.java, which is called by the requestLayout function in view rootimpl.java and the incalidatechildirent function, which is called by the requestLayout function in view.java, which is called by the invalidate function in view.java. In actual use, a user generally uses a View class (including View. java, imageview. java, textview. java, viewgroup. java, and the like) function as a basic function to construct a project code, and therefore, when determining an interface update function, a function using requestLayout and invalid needs to be scanned in the View class as the interface update function. Such as a setText function, a setvisiability function, etc.

Step 12: and generating interface updating function detection data by using the function name corresponding to the interface updating function.

Because the interface updating function can be directly called when in use, and the calling mode is to input the function name, the function name of each interface updating function can be utilized to generate interface updating function detection data, so that the target interface updating function can be subsequently detected by utilizing the interface updating function. Correspondingly, the step of performing interface update function detection on the item code to be detected to obtain the target interface update function may include:

step 13: and performing function name matching on each function to be tested in the project codes to be tested by using the interface updating function detection data.

Step 14: and determining the function to be tested matched with the function name as a target interface updating function.

When the interface updating function is detected, the interface updating function detection data can be used as a matching standard to perform function name matching on each function to be detected in the item codes to be detected, and the function to be detected can be any one of the item codes to be detected. If the function name of the function to be tested is matched with a certain function name in the item code to be tested, the function name is matched, and the matched function to be tested is the target interface updating function.

Based on the foregoing embodiment, in a specific implementation manner, in order to improve the universality and achieve the effect of flexibly selecting a computing device and quickly enabling the computing device to have the interface update crash risk detection capability when needed, the function call relationship information may be acquired by using a plug-in detection manner. Specifically, the process of generating the function call relationship information corresponding to the item code to be tested may specifically include the following steps:

step 21: acquiring a detection plug-in and corresponding detection plug-in information;

it can be understood that the specific type of the detection plug-in may also be different according to different acquisition schemes adopted by the function call relation information. For example, when the function call relation information is acquired by using the ASM scheme, the detection plug-in may be an ASM instrumentation plug-in. The detection plug-in information is used for communicating with the project code to be detected to generate a detection script, and the specific content is not limited, and may be, for example, an operation mode. The detection plug-in may be generated in advance, and the specific generation manner may refer to related technologies, which are not described herein again. It should be noted that the detection plug-in may be different according to the specific type of the electronic device.

Step 22: adding the detection plug-in information into the item code to be detected, compiling the item code, calling the detection plug-in the compiling process to obtain function calling relation information

The detection plug-in information is combined with the item code to be detected and then compiled, specifically, the detection plug-in information can be configured into a build. At compile time, a detection plug-in may be called based on the above configuration, and function call relation information may be generated by the detection plug-in according to its internal logic. By setting the compiling mode of the detection plug-in, the function call relation information can be generated on any electronic equipment (such as android equipment) matched with the detection plug-in when needed, so that the CRash risk detection of UI updating is completed, and the universality is improved.

Based on the foregoing embodiment, in an implementation, since the target interface update function may be called for multiple times, and the number of times of calling different target interface update functions may be different, in order to accurately construct a function chain and further accurately identify the second end function, a process of taking each target interface update function as a first end function, constructing multiple function chains by using function call relation information, and identifying the second end function corresponding to each function chain may include the following steps:

step 31: and determining the direct calling function corresponding to each target interface updating function by using the function calling relation information.

In this embodiment, in order to quickly construct the function chain, the function call relationship information may include direct call information, where the direct call information records each target interface update function and a direct call function that directly calls the target interface update function. By directly calling the information, the directly called function can be directly obtained, and the calling relation among all functions corresponding to the project code to be tested does not need to be screened according to the target interface updating function, so that the construction speed of the function chain can be improved. The direct call information may be referred to as ViewMethod information, which may be in the form of txt, and specifically, may be in the content format of:

class A name- -function A- -A parameter- -A parent class- -A interface list { class B name- -called target interface update function B- -B parameter };

in one embodiment, one A function may call multiple target interface update functions, in which case the first target interface update function called by the A function may be determined to be the B function. Therefore, when the direct call information is generated, when the target interface update function and the corresponding direct call function are detected, whether the target interface update function is the first interface update function called by the direct call function can be judged, if yes, the corresponding relation is written into the direct call information, and if not, no operation is executed.

Step 32: and determining the direct calling function as the called function, and judging whether a superior function corresponding to the called function exists or not by utilizing the function calling relation information.

In this embodiment, the function call relation information may include function relation information, where the function relation information is information for recording call relations existing between all functions corresponding to the item code to be tested. Since there may be a multi-layer call, after determining to directly call the function, it may also be determined whether the called function is called by another function by using the function relationship information, that is, whether there is a higher-level function corresponding to the called function. The functional relationship information may be referred to as Method information, and may be in the form of txt, and specifically, the content format may be:

a class A name-function A-A parameter-A parent-A interface list { class B name-called function B-B parameter, class C name-called function C-C parameter };

it will be appreciated that this format calls B, C, and other functions for the a function.

Step 33: and if the upper function exists, determining the upper function as the called function.

If there is an upper function, it indicates that the current called function is still called by other functions, so that the upper function may be determined as a new called function, so as to perform the step of determining whether there is an upper function corresponding to the called function by using the function call relation information again, and determine whether there is an upper function still.

Step 34: and if no superior function exists, determining that the function chain is completely constructed, and determining the function to be established as a second end function.

If the called function does not have a superior function, it indicates that the called function is not called by any function, which is the initiating end of the function chain. In this case, it may be determined that the function chain is constructed, and the function to be constructed is determined as the second end function.

Further, in one embodiment, a rewrite function may be present in the item code under test. The rewriting function is a function obtained by performing function rewriting processing on a parent function or an interface function. Function rewriting is actually function coverage, when a member function completely identical to the base function is declared in the derivative class, coverage of the base function is achieved, and the rewritten derivative class function, namely the rewriting function, is actually called when the base function is called. When the function is rewritten, the function class name may be modified, and therefore, if the function to be rewritten is a rewritten function, the function class name may be different from the function class name of the parent function or the interface function corresponding to the rewritten function, and therefore, it may be mistaken that there is no superior function, which causes a function chain break, so that the generated function chain is an erroneous function chain. In order to solve this problem, if there is no superior function, the process of determining that the function chain is completely constructed may include the following steps:

step 41: if no superior function exists, judging whether the called function has a corresponding target parent function or a target interface function by using the function call relation information.

In this embodiment, the function call relationship information may also include rewrite function information, where the rewrite function information is used to record a correspondence between each rewrite function and its corresponding parent function or interface function. If a certain called function does not have a superior function, it is indicated that the function may be a rewrite function, and in this case, the rewrite function information may be screened by using the function, so as to determine whether a target parent function or a target interface function corresponding to the function exists. The rewrite function information may be referred to as Super _ Inter _ Method information, and may be in the form of txt, and specifically, the content format may be:

a class A name-parent class or interface function A-A parameter-A parent class-A interface list { class B name-rewrite function B-B parameter, class C name-rewrite function C-C parameter, };

it should be noted that, only the function class name is different between the called function and the target parent function or the target interface function, and other contents are the same. Taking the above content format as an example, the class a name is different from the class B name, the a parameter is the same as the B parameter, and the parent or interface function a (i.e., the function name of the a function) is the same as the rewrite function B (i.e., the function name of the B function). Therefore, when judging whether a target parent function or a target interface function exists, the function with the same function name and function parameter can be judged according to whether a function different from the called function class name exists.

Step 42: and if the target parent function or the target interface function exists, determining the target parent function or the target interface function as the called function.

If the function chain exists, the current called function can be determined to be the rewriting function, so that in order to avoid function chain breakage, the target parent function or the target interface function can be determined to be a new called function, so that the step of judging whether the superior function corresponding to the called function exists or not by using the function call relation information is re-executed by using the new called function, and the function chain is continuously constructed, so that an accurate function chain is obtained.

Step 43: and if the target parent function or the target interface function does not exist, determining that the function chain is completely constructed.

And if the target parent function or the target interface function does not exist, indicating that the called function is the second port function, and determining that the function chain is completely constructed. Specifically, the format of the function chain may be:

{

class A name- -function A- -A parameter (first end)

Class B name-function B-B parameter

Class C name- -function C- -C parameter

...

Class X name- -function X- -X parameter (second end)

}

Therefore, the function chain indicates that the A function is called by the B function, the B function is called by the C function, and so on, and the finally obtained second end function is the X function.

Based on the above embodiment, in an implementation manner, there may be an un-called function in the item code to be tested, for example, the item code to be tested is modified for multiple times, and then the function is called before modification but not called after modification. Although the functions exist, the functions are not called by the item code to be tested, namely the functions are not executed, so that even if the target interface updating function is finally called, the UI updating cannot be caused when the item code to be tested runs, and the risk of CRash of the UI updating does not exist. Therefore, in order to improve the accuracy of risk detection, the present embodiment may further include:

step 51: and acquiring the information of the call-free function, and marking the function corresponding to the information of the call-free function in the item code to be tested as the call-free function.

In this embodiment, the call-free function information may be composed of a function name, a function parameter, and a function class name, or may be a function number or the like. After the information of the non-call function is obtained, the function corresponding to the information of the non-call function can be marked as a non-call function, that is, the functions are not really called, that is, not executed, although the functions exist in the item code to be tested.

Correspondingly, if any second end function is a non-main thread function, the process of determining that the objective function chain to which the non-main thread function belongs has the risk of interface update crash may include the following steps:

step 52: if any second end function is a non-main thread function, judging whether the non-main thread function is a call-free function.

When the non-main thread function is detected to exist, whether the non-main thread function is a non-calling function or not can be further judged, and error detection on the CRash risk of updating the UI is prevented. The embodiment does not limit the specific determination manner, for example, the function name, the function parameter and the function class name of the non-main thread function may be used to match with the function name, the function parameter and the function class name of the call-free function, respectively, if the function name, the function class name and the function parameter are the same, it is determined that the matching is successful, and if the matching is successful, it is determined that the function is the call-free function; or the function content of the non-main thread function can be matched with the function content of the non-calling function, and if the matching is successful, the non-calling function is determined.

Step 53: and if any non-main thread function is not a call-free function, determining that the target function chain has the risk of interface update breakdown.

If the non-main thread function is not a call-free function, it indicates that the non-main thread function is actually called, i.e. is actually executed, and it is a non-main thread function, which indicates that it is likely to be called by a sub-thread, so it is determined that the target function chain to which it belongs has a risk of crash for UI update, i.e. a risk of collapse for interface update. By judging whether the non-main thread function is a call-free function, risk misinformation can be avoided, and detection accuracy is improved.

Further, in order to enable the user to accurately know the specific position of the CRash risk of the UI update, the user can efficiently repair the risk. Specifically, the method can further comprise the following steps:

step 61: and generating a detection result by using the objective function chain.

By utilizing the target function chain to generate the detection result, the specific function and the function chain causing the risk of interface update collapse can be accurately described in the detection result, so that a user can carry out risk repair on the specific function and the function chain.

Step 62: and acquiring executor information corresponding to the item code to be detected, and feeding back a detection result by using the executor information.

Because the detection of each item code to be detected needs a certain time, executor information corresponding to the item code to be detected can be preset, the executor information can represent a user corresponding to the item code to be detected, and the user can know the detection result at the first time after the detection is finished by feeding back the detection result by the executor information.

The interface update crash risk detection apparatus provided in the embodiments of the present application is introduced below, and the interface update crash risk detection apparatus described below and the interface update crash risk detection method described above may be referred to in a corresponding manner.

Referring to fig. 5, fig. 5 is a schematic structural diagram of an interface update crash risk detection apparatus according to an embodiment of the present application, including:

the update function detection module 110 is configured to obtain a project code to be detected, and perform interface update function detection on the project code to be detected to obtain a target interface update function;

a function call relation information generating module 120, configured to generate function call relation information corresponding to the item code to be tested;

a function chain construction module 130, configured to use each target interface update function as a first end function, construct a plurality of function chains by using the function call relationship information, and identify a second end function corresponding to each function chain;

the risk detection module 140 is configured to determine that the objective function chain to which the non-main thread function belongs has an interface update collapse risk if any of the second end functions is the non-main thread function.

By applying the interface updating collapse risk detection device provided by the embodiment of the application, when the project code to be tested is tested, the target interface updating function is firstly identified, and the target interface updating function is a function which can cause UI updating in the project code to be tested. And after the target interface updating function is obtained, generating function calling relation information based on the target interface updating function. The function call relation information records the call relations among all functions in the item code to be tested, so that the function call relation information can be used for screening and obtaining the call relations among all functions related to the target interface updating function in the item code to be tested. And taking the target interface updating function as a first end function, and taking the function corresponding to the other end of the function chain as a second end function. If the second end function is a non-main thread function, it indicates that the second end function is not a function which can only be called by the main thread, and may be called by the sub-thread, and the sub-thread calling the second end function may cause the sub-thread to update the UI, so that there is a risk of UI updating crash, that is, it is determined that the target function chain to which the second end function belongs has a risk of interface updating collapse. The device adopts the mode of static test, can accurately and comprehensively identify the UI updating crash that the item code to be detected exists, can cover all detection scenes, and detection effect is better. And random detection is not needed, so that the detection time is short, the detection efficiency is high, and the problems of poor test effect and low test efficiency in the related technology are solved.

Optionally, the function chain building module 130 includes:

the direct call function determining unit is used for determining a direct call function corresponding to each target interface updating function by using the function call relation information;

a superior function judging unit, configured to determine the direct call function as a called function, and judge whether a superior function corresponding to the called function exists by using the function call relation information;

a called function determining unit, configured to determine, if there is a superior function, the superior function as a called function;

and the second end function determining unit is used for determining that the function chain is completely constructed and determining the function to be established as the second end function if the superior function does not exist.

Optionally, the second end function determining unit includes:

the rewriting judgment subunit is configured to, if no superior function exists, judge whether the called function has a corresponding target parent function or a target interface function by using the function call relationship information;

the called function determining subunit is used for determining the target parent function or the target interface function as a called function if the target parent function or the target interface function exists;

and the construction completion determining subunit is used for determining that the function chain is completely constructed if the target parent function or the target interface function does not exist.

Optionally, the method further comprises:

the interface updating function determining module is used for screening each function by using the interface updating basic function and determining the function which calls the interface updating basic function as the interface updating function;

the detection data generation module is used for generating interface updating function detection data by using the function name corresponding to the interface updating function;

accordingly, the update function detection module comprises:

the function name matching unit is used for performing function name matching on each function to be tested in the project codes to be tested by using the interface updating function detection data;

and the target interface updating function determining unit is used for determining the function to be tested matched with the function name as a target interface updating function.

Optionally, the function call relation information generating module includes:

the plug-in acquisition unit is used for acquiring the detection plug-in and corresponding detection plug-in information;

and the detection script generation unit is used for adding the detection plug-in information into the item code to be detected, compiling the item code and calling the detection plug-in the compiling process to obtain the function calling relation information.

Optionally, the method further comprises:

the detection result generation module is used for generating a detection result by utilizing the target function chain;

and the result feedback module is used for acquiring the executor information corresponding to the item code to be detected and feeding back the detection result by using the executor information.

Optionally, the method further comprises:

the non-call function marking module is used for acquiring non-call function information and marking a function corresponding to the non-call function information in the item code to be tested as a non-call function;

accordingly, a risk detection module, comprising:

a call-free function judging unit, configured to judge whether a non-main thread function is a call-free function if any of the second end functions is the non-main thread function;

and the risk determining unit is used for determining that the target function chain has the interface updating collapse risk if any non-main thread function is not a call-free function.

In the following, a computer-readable storage medium provided by the embodiments of the present application is introduced, and the computer-readable storage medium described below and the interface update crash risk detection method described above may be referred to correspondingly.

The application further provides a computer-readable storage medium, on which a computer program is stored, and when the computer program is executed by a processor, the steps of the interface update crash risk detection method are implemented.

The computer-readable storage medium may include: various media capable of storing program codes, such as a usb disk, a removable hard disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), a magnetic disk, or an optical disk.

The embodiments are described in a progressive manner, each embodiment focuses on differences from other embodiments, and the same or similar parts among the embodiments are referred to each other. The device disclosed by the embodiment corresponds to the method disclosed by the embodiment, so that the description is simple, and the relevant points can be referred to the method part for description.

Those of skill would further appreciate that the various illustrative components and algorithm steps described in connection with the embodiments disclosed herein may be implemented as electronic hardware, computer software, or combinations of both, and that the various illustrative components and steps have been described above generally in terms of their functionality in order to clearly illustrate this interchangeability of hardware and software. Whether such functionality is implemented as hardware or software depends upon the particular application and design constraints imposed on the implementation. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present application.

The steps of a method or algorithm described in connection with the embodiments disclosed herein may be embodied directly in hardware, in a software module executed by a processor, or in a combination of the two. A software module may reside in Random Access Memory (RAM), memory, Read Only Memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, registers, hard disk, a removable disk, a CD-ROM, or any other form of storage medium known in the art.

Finally, it should also be noted that, herein, relationships such as first and second, etc., are intended only to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. Also, the terms include, or any other variation is intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that includes a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus.

The principle and the implementation of the present application are explained herein by applying specific examples, and the above description of the embodiments is only used to help understand the method and the core idea of the present application; meanwhile, for a person skilled in the art, according to the idea of the present application, there may be variations in the specific embodiments and the application scope, and in summary, the content of the present specification should not be construed as a limitation to the present application.

Claims

1. A method for detecting a risk of collapse of an interface update is characterized by comprising the following steps:

2. The method for detecting interface update crash risk according to claim 1, wherein the step of taking each target interface update function as a first end function, constructing a plurality of function chains by using the function call relationship information, and identifying a second end function corresponding to each function chain includes:

3. The interface update crash risk detection method of claim 2, wherein determining that the function chain is constructed if the superior function does not exist comprises:

4. The interface update crash risk detection method of claim 1, further comprising, before performing interface update function detection on the item code to be detected:

5. The interface update crash risk detection method of claim 1, wherein the generating function call relationship information corresponding to the item code to be tested comprises:

acquiring a detection plug-in and corresponding detection plug-in information;

6. The interface update crash risk detection method of claim 1, further comprising:

generating a detection result by using the objective function chain;

7. The interface update crash risk detection method of any one of claims 1 to 6, further comprising:

8. An interface update crash risk detection apparatus, comprising:

9. An electronic device comprising a memory and a processor, wherein:

the memory is used for storing a computer program;

the processor is configured to execute the computer program to implement the interface update crash risk detection method according to any one of claims 1 to 7.

10. A computer-readable storage medium for storing a computer program, wherein the computer program, when executed by a processor, implements the interface update crash risk detection method of any one of claims 1 to 7.