CN111611153B - Method and device for detecting overdrawing of user interface - Google Patents
Method and device for detecting overdrawing of user interface Download PDFInfo
- Publication number
- CN111611153B CN111611153B CN201910140858.0A CN201910140858A CN111611153B CN 111611153 B CN111611153 B CN 111611153B CN 201910140858 A CN201910140858 A CN 201910140858A CN 111611153 B CN111611153 B CN 111611153B
- Authority
- CN
- China
- Prior art keywords
- source code
- overdrawing
- user interface
- information
- matching
- 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.)
- Active
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/3604—Software analysis for verifying properties of programs
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/38—Creation or generation of source code for implementing user interfaces
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Human Computer Interaction (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Stored Programmes (AREA)
- Debugging And Monitoring (AREA)
Abstract
The invention discloses a method and a device for detecting overdrawing of a user interface. The method comprises the following steps: acquiring an inspection result of executing preset inspection on an application program source code file; searching a preset character string from the detection result, and matching the over-drawing information of the user interface source code with the over-drawing included in the source code of the application program according to the searched character string. The user interface overdrawing condition of the application program can be automatically detected, the labor cost is saved, and the detection efficiency and accuracy are improved.
Description
Technical Field
The present invention relates to the field of application detection technologies, and in particular, to a method and an apparatus for detecting excessive user interface drawing.
Background
Over-rendering of User Interfaces (UIs) often occurs in operating systems, such as Applications (APPs) of the android system. Overdrawing means that a certain pixel area on the screen is drawn multiple times within the same frame. In order to maintain the smoothness of vision, the screen refresh frequency of the mobile phone is usually set to 60hz, that is, one frame is updated in 1000/60=16.67 ms, so that excessive drawing wastes a large amount of CPU and GPU resources, and the UI cannot be updated to the next frame in a set frequency to cause frame dropping, thereby causing UI blocking.
In the prior art, the inspection of overdrawing is mainly finished by a manual click test. The method for judging by human eyes is time-consuming and labor-consuming, and the human subjective judgment is easy to be wrong, especially under the condition that the detection personnel are tired visually.
Disclosure of Invention
The present invention has been made in view of the above problems, and has as its object to provide a method and apparatus for detecting overdrawing of a user interface that overcomes or at least partially solves the above problems.
In a first aspect, an embodiment of the present invention provides a method for detecting overdrawing of a user interface, including:
acquiring an inspection result of executing preset inspection on an application program source code file;
searching a preset character string from the checking result, and matching out over-drawing information of user interface source codes with over-drawing included in the source codes of the application program according to the searched character string.
In some alternative embodiments, obtaining the inspection result of performing the preset inspection on the application source code file includes:
and acquiring a checking result of executing static code analysis on the data under the appointed directory of the application source code file.
In some alternative embodiments, the overdraw information includes:
and the name of the document where the over-drawn user interface source code exists, the position in the document and the path of the document where the over-drawn user interface source code exists.
In some optional embodiments, after matching the over-rendering information including the user interface source code with the over-rendering included in the application source code according to the searched character string, the method further includes:
matching the overdrawing information with a pre-established view-free list;
if the matching is successful, the over-drawing information is ignored;
and if the matching fails, writing the overdrawing information into an overdrawing report.
In some alternative embodiments, matching the overdraw information with a pre-established list of no-view views includes performing at least one of:
matching the name of the document where the overstock user interface source code exists and the name of the document corresponding to the overstock source code in the pre-established inspection-free view list;
matching the position of the overdrawing user interface source code in the document with overdrawing and the position corresponding to the inspection-free source code in the inspection-free view list;
and matching the path of the document where the overdrawing user interface source code exists, which is included in the overdrawing information, with the document path corresponding to the overdrawing source code in the inspection-free view list.
In some alternative embodiments, the method further comprises:
and when the excessive drawing information of the matching failure does not exist, packaging the source code file of the application program, and generating an installation package of the application program.
In a second aspect, an embodiment of the present invention provides a device for detecting excessive drawing of an interface, including:
the acquisition module is used for acquiring an inspection result of executing preset inspection on the application program source code file;
the searching module is used for searching a preset character string from the checking result acquired by the acquiring module;
and the first matching module is used for matching out the overdrawing information of the user interface source code with overdrawing included in the source code of the application program according to the character string searched by the searching module.
In some optional embodiments, the acquiring module is specifically configured to:
and acquiring a checking result of executing static code analysis on the data under the appointed directory of the application source code file.
In some alternative embodiments, the apparatus further comprises:
the second matching module is used for matching the overdrawing information matched by the first matching module with a pre-established view list without inspection; if the matching is successful, the over-drawing information is ignored; and if the matching fails, writing the overdrawing information into an overdrawing report.
In a third aspect, embodiments of the present invention provide a computer-readable storage medium having stored thereon computer instructions that, when executed by a processor, implement the above-described method of detecting user interface overdrawing.
In a fourth aspect, an embodiment of the present invention provides a detector, including: the device comprises a memory, a processor and a computer program stored in the memory and capable of running on the processor, and is characterized in that the processor realizes the method for detecting the overdrawing of the user interface when executing the program.
The technical scheme provided by the embodiment of the invention has the beneficial effects that at least:
acquiring an inspection result of executing preset inspection on an application program source code file; searching a preset character string from the detection result, and matching the over-drawing information of the user interface source code with the over-drawing included in the source code of the application program according to the searched character string. The method and the device can automatically detect the overdrawing condition of the user interface of the application program, do not need manual intervention, save labor cost, and avoid manual operation errors, thereby greatly improving detection efficiency and accuracy; the method can help research and development personnel find out the problem of excessive drawing more conveniently and accurately, save memory resources and improve the user experience of the application program.
Additional features and advantages of the invention will be set forth in the description which follows, and in part will be obvious from the description, or may be learned by practice of the invention. The objectives and other advantages of the invention will be realized and attained by the structure particularly pointed out in the written description and claims thereof as well as the appended drawings.
The technical scheme of the invention is further described in detail through the drawings and the embodiments.
Drawings
The accompanying drawings are included to provide a further understanding of the invention and are incorporated in and constitute a part of this specification, illustrate the invention and together with the embodiments of the invention, serve to explain the invention. In the drawings:
FIG. 1 is a flowchart of a method for detecting user interface overdrawing according to a first embodiment of the invention;
FIG. 2 is a flowchart of an implementation of a method for detecting excessive user interface drawing according to a second embodiment of the present invention;
fig. 3 is a schematic structural diagram of a detection device for overdrawing a user interface according to an embodiment of the invention.
Detailed Description
Exemplary embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. While exemplary embodiments of the present disclosure are shown in the drawings, it should be understood that the present disclosure may be embodied in various forms and should not be limited to the embodiments set forth herein. Rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the scope of the disclosure to those skilled in the art.
In order to solve the problems that manual detection is excessively drawn, time and labor are wasted and mistakes are prone to occur in the prior art, the embodiment of the invention provides the detection method and the device for the user interface is excessively drawn, the excessive drawing can be automatically detected, the labor cost is saved, and the detection efficiency and the detection accuracy are improved.
Example 1
An embodiment of the present invention provides a method for detecting overdrawing of a user interface, the flow of which is shown in fig. 1, comprising the following steps:
step S11: and obtaining an inspection result of executing the preset inspection on the application program source code file.
Specifically, a result of checking the static code analysis performed on the data in the specified directory of the application source code file may be obtained.
For example, an Android packaging platform, that is, a platform for compiling and packaging Android application source code files to generate an Android Package (apk), often executes the link inspection on source codes contained in all files under a root directory of the application source code files after compiling and before packaging the application source code files, and outputs inspection results, so that a developer can find and modify corresponding problems in the application source code until no problems exist in the inspection results or the problems in the inspection results can be ignored, and then compiles and packages the application source code files to generate the Android Package. The inspection result generated in the process comprises the inspection result of the over-drawing aspect of each user interface source code, so that the inspection result is obtained, and the over-drawing detection can be carried out on the user interface source codes in the application program source codes.
Optionally, the inspection result in the above process may also be an inspection result of the android package platform executing the link inspection under other directories of the application source code file.
The static code analysis described above enables checking of bugs, optimizations, security, availability, etc. present in the source code, including but not limited to suspicious type combinations, unused variables, unreachable code, and non-portable code. The examination results from the line examination may include a series of diagnostic information including overdraw information. Alternatively, if only the information on the overdrawing aspect of the source code needs to be known, only the inspection on the overdrawing aspect of the source code may be performed.
Alternatively, the inspection result of the preset inspection of the application source code file by other packaging platforms or static code analysis tools can be obtained, so long as the inspection result contains the overdrawing information.
Step S12: searching a preset character string from the detection result, and matching the over-drawing information of the user interface source code with the over-drawing included in the source code of the application program according to the searched character string.
Specifically, the overdrawing information includes a document name where the overdrawing user interface source code exists, a position in the document where the overdrawing user interface source code exists, and a path of the document where the overdrawing user interface source code exists. The document can be found according to the path of the document where the over-drawn source code exists and the name of the document where the over-drawn source code exists, and then the specific content of the over-drawn source code can be determined according to the position of the over-drawn source code in the document where the over-drawn source code exists.
Optionally, the overdraw information may further include: there is overdrawn user interface source code and overdrawn description information.
Taking the inspection result of executing the link inspection on the data under the root directory of the application source code file by using the android packaging platform as an example. The preset character string may be: id= "Overdraw"; correspondingly, the over-drawing information of the user interface source code included in the application source code is matched according to the searched character string, and may be: starting from each searched string, searching the nearest preset corresponding string, and matching corresponding overdrawing information according to the searched string and the corresponding string.
Acquiring an inspection result of executing preset inspection on an application program source code file; searching a preset character string from the detection result, and matching the over-drawing information of the user interface source code with the over-drawing included in the source code of the application program according to the searched character string. The user interface overdrawing condition of the application program can be automatically detected, manual intervention is not needed, the labor cost is saved, and manual operation errors are avoided, so that the detection efficiency and accuracy are improved; the method can help research and development personnel find out the problem of excessive drawing more conveniently and accurately, save memory resources and improve the user experience of the application program.
Optionally, after the over-drawing information of the user interface source code included in the application source code is matched according to the searched character string, all the over-drawing information can be written into the over-drawing report.
And screening all the overdrawing information according to a preset rule, and writing the screened overdrawing information into an overdrawing report.
Specifically, all the overdrawing information is screened according to a preset rule, and the overdrawing information can be matched with a pre-established view list without inspection; if the matching is successful, the over-drawing information is ignored; if the matching fails, the overdrawing information is written into an overdrawing report.
Specifically, matching the overdrawing information with the pre-established list of no-view views may include performing at least one of:
1. and matching the document name of the over-drawn user interface source code included in the over-drawn information with the document name corresponding to the over-drawn source code in the pre-established list of the inspection-free view.
2. And matching the position of the overdrawing information included in the overdrawing information in the document where the overdrawing user interface source code exists with the position corresponding to the inspection-free source code in the inspection-free view list.
3. And matching the path of the document where the overdrawing user interface source code exists, which is included in the overdrawing information, with the document path corresponding to the inspection-free source code in the inspection-free view list.
Specifically, the non-inspection view list may be updated in real time, for example, the source code of the application program may be automatically monitored, and when the source code is found to be updated, the over-drawing information in the non-inspection view list is adaptively updated, including the change of the content of the over-drawing information, and also including the deletion or addition of the over-drawing information of the non-inspection. In particular, the modification of the exempt overdrawing information content may be automatically performed; the adding or subtracting may be performed interactively with the developer, for example: and popping up a pop-up window for adding the non-inspection overdrawing information, wherein the specific content of the added non-inspection overdrawing information is displayed for a developer to read, and meanwhile, a prompt statement whether to add and two selection buttons of yes and no are displayed, if yes, the non-inspection overdrawing information is added to the non-inspection overdrawing information, and if no instruction is received, the non-inspection overdrawing information is ignored.
And matching each item of overdrawing information with the inspection-free overdrawing information, and if the matching fails, writing the overdrawing information into an overdrawing report. The method and the device avoid that some negligible overdrawing information in the checking result is recorded in the overdrawing report, so that a developer does not need to carry out secondary manual screening when reading the generated report, and time and labor are saved.
In some alternative embodiments, the application source code file may be packaged to generate an installation package for the application when there is no overdrawing information that fails to match.
Example two
The second embodiment of the present invention provides a specific implementation of a method for detecting excessive drawing of a user interface, taking an example that an obtained inspection result is an inspection result of executing a line inspection on data under a root directory of an application source code file, a flow of which is shown in fig. 2, and the method includes the following steps:
step S21: and acquiring an inspection result of the android packaging platform for executing the link inspection on the data under the root directory of the application source code file.
In the prior art, in the process of compiling and packaging an application program source code file, an android packaging platform automatically executes a gradlew link command on data under a root directory of the application program source code file after compiling and before packaging, carries out link inspection, and automatically generates an inspection result link-results.
Step S22: and analyzing the overdrawing information from the checking result.
One item of the overdraw information parsed from the inspection result may be the following:
<issue id＝"Overdraw"；severity＝"Warning"；message＝"Possible overdraw:……"；category＝"Performance"；priority＝"3"；summary＝"Overdraw:Painting regions more than once"；explanation＝"……"<location file＝"/Users/roc/lab/MyAlg/app/src/main/res/layout/activity_main.xml",line＝"9",column＝"5"/></issue>
the overdrawing information includes the name of the document where the overdrawing source code exists, the position in the document and the path of the document
Each question in the examination result is marked as an issue, where the id number indicates the category of the question, or the identity of the question, and the priority of the line examination, i.e. its severity, is set after the id number. And a specific line of source codes has problems and is positioned to the specific problem, so that a developer can read and know the problem, rewrite the source codes and ensure the code quality of the application program source codes when the application program source codes are finally on line.
The id after the issue is "Overdraw", which indicates Overdraw information, and the Overdraw information is taken as an example, where the content is: safety: reminding; message: potentially overdraw items; category: displaying; priority (severity level): 3, a step of; summary: drawing more than once; a description; there is an overdrawn source code document name: activity_main. There is a position in the document where the overdrawn source code is located: line= "9", column= "5"; there is a path of the document where the overdrawn source code is located: users/roc/lab/MyAlg/app/src/main/res/layout/.
Specifically, the over-drawing information is resolved from the inspection result, which may be that a preset character string id= "Overdraw" is searched from the inspection result; starting from each searched string id= "Overdraw", searching the nearest preset corresponding string </issue >, and matching corresponding overdrawing information, such as the overdrawing information, according to the searched string and the corresponding string.
Step S23: and matching the analyzed overdrawing information with a pre-established non-inspection view list.
Taking the overdrawing information illustrated in the step S22 as an example, matching the document name activity_main.xml where the overdrawing information is located, the start position line= "9" in the document where the overdrawing information is located, column= "5" and the relative path src/main/res/layout of the document where the overdrawing information is located with the content of one item of overdrawing information in the exempt white list, if the overdrawing information is matched, the matching is successful; there is at least one mismatch, indicating a match failure.
If the matching is successful, executing step S24; if the match fails, step S25 is performed.
Step S24: the overdraw information is ignored.
If the match is successful, this overdraw information is declared as a non-checkable. Listed in the view-free list is a list of special xml views that need to be ignored, which views, although found to have problems with overdrawing, are ignored for necessary or more complex view effect selections. Therefore, the overdraw information matching the exempt Bai Shitu list is ignored.
Step S25: the overdraw information is written into an overdraw report.
Step S26: an overdraw report is generated.
And directly displaying the generated overdrawing report to a client, sending the overdrawing report to a specified mail, or storing the overdrawing report in a specified directory.
Based on the same inventive concept, the embodiment of the invention further provides a device for detecting excessive drawing of an interface, the structure of which is shown in fig. 3, comprising:
an obtaining module 31, configured to obtain an inspection result of performing a preset inspection on the application source code file;
a searching module 32, configured to search a preset character string from the inspection result acquired by the acquiring module 31;
the first matching module 33 is configured to match, according to the string found by the finding module 32, overdrawing information of user interface source codes included in the source codes of the application program, where the overdrawing information includes source codes with overdrawing and a document where the source codes are located, a location in the document where the source codes are located, a path of the document where the source codes are located, and overdrawing description information.
In some alternative embodiments, the obtaining module 31 is specifically configured to:
and acquiring a checking result of executing static code analysis on the data under the appointed directory of the application source code file.
In some alternative embodiments, the apparatus further comprises:
a second matching module 34, configured to match the overdrawing information matched by the first matching module 33 with a pre-established view-free list; if the matching is successful, the over-drawing information is ignored; and if the matching fails, writing the overdrawing information into an overdrawing report.
In some alternative embodiments, the second matching module 34 is specifically configured to:
performing at least one of:
matching the name of the document where the overdrawing source code exists, which is included in the overdrawing information, with the name of the document corresponding to the inspection-free source code in a pre-established inspection-free view list;
matching the position of the overdrawing information included in the overdrawing information in the document where the overdrawing source code exists with the position corresponding to the inspection-free source code in the inspection-free view list;
and matching the path of the document where the overdrawing source code exists, which is included in the overdrawing information, with the document path corresponding to the inspection-free source code in the inspection-free view list.
In some alternative embodiments, the apparatus further comprises:
and the packaging module 35 is configured to package the application source code file and generate an installation package of the application when there is no overdrawing information that fails to match.
The specific manner in which the various modules perform the operations in the apparatus of the above embodiments have been described in detail in connection with the embodiments of the method, and will not be described in detail herein.
Based on the same inventive concept, the embodiments of the present invention also provide a computer-readable storage medium having stored thereon computer instructions that, when executed by a processor, implement the above-described method of detecting user interface overdrawing.
Based on the same inventive concept, an embodiment of the present invention further provides a detector including: the system comprises a memory, a processor and a computer program stored in the memory and capable of running on the processor, wherein the processor realizes the method for detecting the overdrawing of the user interface when executing the program.
Unless specifically stated otherwise, terms such as processing, computing, calculating, determining, displaying, or the like, may refer to an action and/or process of one or more processing or computing systems, or similar devices, that manipulates and transforms data represented as physical (e.g., electronic) quantities within the processing system's registers or memories into other data similarly represented as physical quantities within the processing system's memories, registers or other such information storage, transmission or display devices. Information and signals may be represented using any of a variety of different technologies and techniques. For example, data, instructions, commands, information, signals, bits, symbols, and chips that may be referenced throughout the above description may be represented by voltages, currents, electromagnetic waves, magnetic fields or particles, optical fields or particles, or any combination thereof.
It should be understood that the specific order or hierarchy of steps in the processes disclosed are examples of exemplary approaches. Based on design preferences, it is understood that the specific order or hierarchy of steps in the processes may be rearranged without departing from the scope of the present disclosure. The accompanying method claims present elements of the various steps in a sample order, and are not meant to be limited to the specific order or hierarchy presented.
In the foregoing detailed description, various features are grouped together in a single embodiment for the purpose of streamlining the disclosure. This method of disclosure is not to be interpreted as reflecting an intention that the claimed embodiments of the subject matter require more features than are expressly recited in each claim. Rather, as the following claims reflect, invention lies in less than all features of a single disclosed embodiment. Thus the following claims are hereby expressly incorporated into this detailed description, with each claim standing on its own as a separate preferred embodiment of this invention.
Those of skill would further appreciate that the various illustrative logical blocks, modules, circuits, and algorithm steps described in connection with the embodiments disclosed herein may be implemented as electronic hardware, computer software, or combinations of both. To clearly illustrate this interchangeability of hardware and software, various illustrative components, blocks, modules, circuits, and steps have been described above generally in terms of their functionality. Whether such functionality is implemented as hardware or software depends upon the particular application and design constraints imposed on the overall system. 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 disclosure.
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 RAM memory, flash memory, ROM memory, EPROM memory, EEPROM memory, registers, hard disk, a removable disk, a CD-ROM, or any other form of storage medium known in the art. An exemplary storage medium is coupled to the processor such the processor can read information from, and write information to, the storage medium. In the alternative, the storage medium may be integral to the processor. The processor and the storage medium may reside in an ASIC. The ASIC may reside in a user terminal. The processor and the storage medium may reside as discrete components in a user terminal.
For a software implementation, the techniques described herein may be implemented with modules (e.g., procedures, functions, and so on) that perform the functions described herein. These software codes may be stored in memory units and executed by processors. The memory unit may be implemented within the processor or external to the processor, in which case it can be communicatively coupled to the processor via various means as is known in the art.
The foregoing description includes examples of one or more embodiments. It is, of course, not possible to describe every conceivable combination of components or methodologies for purposes of describing the aforementioned embodiments, but one of ordinary skill in the art may recognize that many further combinations and permutations of various embodiments are possible. Accordingly, the embodiments described herein are intended to embrace all such alterations, modifications and variations that fall within the scope of the appended claims. Furthermore, as used in the specification or claims, the term "comprising" is intended to be inclusive in a manner similar to the term "comprising," as interpreted when employed as a transitional word in a claim. Furthermore, any use of the term "or" in the specification of the claims is intended to mean "non-exclusive or".
Claims (9)
1. A method for detecting overdrawing of a user interface, comprising:
acquiring an inspection result of executing preset inspection on data under an appointed directory of an application program source code file;
searching a preset character string from the checking result, and matching over-drawing information of the user interface source code with over-drawing included in the source code of the application program according to the searched character string, wherein the over-drawing information comprises the name of the document where the over-drawing user interface source code exists, the position in the document and the path of the document where the over-drawing user interface source code exists.
2. The method of claim 1, wherein obtaining the inspection result of performing the preset inspection on the data under the specified directory of the application source code file comprises:
and acquiring a checking result of executing static code analysis on the data under the appointed directory of the application source code file.
3. The method of claim 1, further comprising, after matching the overspray information of the user interface source code included in the application source code for which the overspray exists according to the searched character string:
matching the overdrawing information with a pre-established view-free list;
if the matching is successful, the over-drawing information is ignored;
and if the matching fails, writing the overdrawing information into an overdrawing report.
4. The method of claim 3, wherein matching the overdraw information to a pre-established list of no-view views comprises performing at least one of:
matching the name of the document where the overstock user interface source code exists and the name of the document corresponding to the overstock source code in the pre-established inspection-free view list;
matching the position of the overdrawing user interface source code in the document with overdrawing and the position corresponding to the inspection-free source code in the inspection-free view list;
and matching the path of the document where the overdrawing user interface source code exists, which is included in the overdrawing information, with the document path corresponding to the overdrawing source code in the inspection-free view list.
5. A method as recited in claim 3, further comprising:
and when the excessive drawing information of the matching failure does not exist, packaging the source code file of the application program, and generating an installation package of the application program.
6. A user interface overdrawing detection apparatus, comprising:
the acquisition module is used for acquiring an inspection result of executing preset inspection on the data under the appointed directory of the application program source code file;
the searching module is used for searching a preset character string from the checking result acquired by the acquiring module;
the first matching module is used for matching the overspray information of the user interface source code with overspray, which is included in the source code of the application program, according to the character string searched by the searching module, wherein the overspray information comprises the name of the document where the overspray user interface source code is located, the position in the document and the path of the document where the overspray user interface source code is located.
7. The apparatus of claim 6, wherein the acquisition module is specifically configured to:
and acquiring a checking result of executing static code analysis on the data under the appointed directory of the application source code file.
8. A computer readable storage medium having stored thereon computer instructions, which when executed by a processor, implement the method of detecting overdrawing of a user interface of any of claims 1-5.
9. A detector, comprising: a memory, a processor and a computer program stored in the memory and executable on the processor, characterized in that the processor implements the method for detecting overdrawing of a user interface according to any of claims 1-5 when executing the program.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910140858.0A CN111611153B (en) | 2019-02-26 | 2019-02-26 | Method and device for detecting overdrawing of user interface |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910140858.0A CN111611153B (en) | 2019-02-26 | 2019-02-26 | Method and device for detecting overdrawing of user interface |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111611153A CN111611153A (en) | 2020-09-01 |
| CN111611153B true CN111611153B (en) | 2023-05-16 |
Family
ID=72199511
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910140858.0A Active CN111611153B (en) | 2019-02-26 | 2019-02-26 | Method and device for detecting overdrawing of user interface |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111611153B (en) |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| JP2007179488A (en) * | 2005-12-28 | 2007-07-12 | Fujitsu Ltd | Program for predicting source code problem |
| CN101017458A (en) * | 2007-03-02 | 2007-08-15 | 北京邮电大学 | Software safety code analyzer based on static analysis of source code and testing method therefor |
| CN102799520A (en) * | 2012-06-27 | 2012-11-28 | 清华大学 | Static checking method and device for source code pairing |
| CN106372507A (en) * | 2016-08-30 | 2017-02-01 | 北京奇虎科技有限公司 | Method and device for detecting malicious document |
| CN109063477A (en) * | 2018-07-18 | 2018-12-21 | 成都链安科技有限公司 | A kind of intelligent contract aacode defect detection system and method for automation |
Family Cites Families (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20060190770A1 (en) * | 2005-02-22 | 2006-08-24 | Autodesk, Inc. | Forward projection of correlated software failure information |
| US10025701B2 (en) * | 2016-05-16 | 2018-07-17 | Google Llc | Application pre-release report |
-
2019
- 2019-02-26 CN CN201910140858.0A patent/CN111611153B/en active Active
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| JP2007179488A (en) * | 2005-12-28 | 2007-07-12 | Fujitsu Ltd | Program for predicting source code problem |
| CN101017458A (en) * | 2007-03-02 | 2007-08-15 | 北京邮电大学 | Software safety code analyzer based on static analysis of source code and testing method therefor |
| CN102799520A (en) * | 2012-06-27 | 2012-11-28 | 清华大学 | Static checking method and device for source code pairing |
| CN106372507A (en) * | 2016-08-30 | 2017-02-01 | 北京奇虎科技有限公司 | Method and device for detecting malicious document |
| CN109063477A (en) * | 2018-07-18 | 2018-12-21 | 成都链安科技有限公司 | A kind of intelligent contract aacode defect detection system and method for automation |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111611153A (en) | 2020-09-01 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US8943423B2 (en) | User interface indicators for changed user interface elements | |
| US9898387B2 (en) | Development tools for logging and analyzing software bugs | |
| US8627290B2 (en) | Test case pattern matching | |
| US8799875B2 (en) | Streamlining unit testing through hot code swapping | |
| US8954930B2 (en) | System and method for reducing test effort by object risk analysis | |
| US9311217B2 (en) | Analyzing computer programs to identify errors | |
| US10289536B2 (en) | Distinguishing public and private code in testing environments | |
| US9256512B1 (en) | Quality analysis for embedded software code | |
| EP3785126B1 (en) | Unit testing for changes to version control | |
| US10296311B2 (en) | Finding uninitialized variables outside the local scope | |
| CN112100072A (en) | Static detection method, device, equipment and medium for application program codes | |
| CN111897727A (en) | Software testing method and device, computer equipment and storage medium | |
| US9563541B2 (en) | Software defect detection identifying location of diverging paths | |
| CN112925524A (en) | Method and device for detecting unsafe direct memory access in driver | |
| CN116991736A (en) | Static code analysis method, device, system and storage medium | |
| US9176846B1 (en) | Validating correctness of expression evaluation within a debugger | |
| US9298584B2 (en) | Artifact selection using textual reports | |
| US8930765B2 (en) | Systems and methods for feedback driven regression testing | |
| CN111611153B (en) | Method and device for detecting overdrawing of user interface | |
| US8291389B2 (en) | Automatically detecting non-modifying transforms when profiling source code | |
| US9710360B2 (en) | Optimizing error parsing in an integrated development environment | |
| US20140074803A1 (en) | Log message optimization to ignore or identify redundant log messages | |
| JP6747161B2 (en) | Software quality judgment method | |
| CN110991147B (en) | Font detection method and device, electronic equipment and storage medium | |
| US20150212993A1 (en) | Impact Coverage |
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 | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |