CN111611153A - Method and device for detecting excessive drawing of user interface - Google Patents
Method and device for detecting excessive drawing of user interface Download PDFInfo
- Publication number
- CN111611153A CN111611153A CN201910140858.0A CN201910140858A CN111611153A CN 111611153 A CN111611153 A CN 111611153A CN 201910140858 A CN201910140858 A CN 201910140858A CN 111611153 A CN111611153 A CN 111611153A
- Authority
- CN
- China
- Prior art keywords
- over
- source code
- user interface
- matching
- inspection
- 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.)
- Granted
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Prevention of errors by analysis, debugging or testing of software
- G06F11/3604—Analysis of software for verifying properties of programs
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; 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 excessive drawing of a user interface. The method comprises the following steps: obtaining a checking result of executing preset checking on the source code file of the application program; and searching a preset character string from the checking result, and matching the over-drawing information of the over-drawn user interface source code included in the application program source code according to the searched character string. The method and the device can automatically detect the excessive drawing condition of the user interface of the application program, save the labor cost and improve the detection efficiency and accuracy.
Description
Technical Field
The invention relates to the technical field of application program detection, in particular to a method and a device for detecting excessive drawing of a user interface.
Background
Often, an operating system, such as an Application (APP) of an android system, has an overdraw of a User Interface (UI). Overdraw means that a certain pixel area on the screen is drawn multiple times within the same frame. In order to maintain visual fluency, the screen refresh frequency of the mobile phone is usually set to 60hz, that is, one frame is updated within 16.67ms from 1000/60, excessive drawing not only wastes a large amount of CPU and GPU resources, but also easily causes the UI to be unable to update to the next frame within the set frequency, and frame drop occurs, thus causing UI deadlock.
In the prior art, the over-drawing inspection is mainly completed by a manual click test. The judgment is time-consuming and labor-consuming through a manual visual observation method, and the manual subjective judgment is easy to have errors, especially under the condition that the detection personnel are visually exhausted.
Disclosure of Invention
In view of the above, the present invention has been made 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 overdraw of a user interface, including:
obtaining a checking result of executing preset checking on the source code file of the application program;
and searching a preset character string from the checking result, and matching out the over-drawing information of the over-drawn user interface source code according to the searched character string.
In some optional embodiments, obtaining a check result of performing a preset check on the application source code file includes:
and acquiring a check result of performing static code analysis on the data in the specified directory of the source code file of the application program.
In some optional embodiments, the overdraw information comprises:
and the document name of the over-drawn user interface source code, the position of the over-drawn user interface source code in the document and the path of the over-drawn user interface source code in the document are determined.
In some optional embodiments, after matching the over-rendering information of the user interface source code with over-rendering included in the application source code according to the found character string, the method further includes:
matching the over-drawing information with a pre-established inspection-free view list;
if the matching is successful, ignoring the over-drawing information;
and if the matching fails, writing the over-drawing information into an over-drawing report.
In some optional embodiments, matching the overdraw information to a pre-established list of exempt views includes performing at least one of:
matching the name of the document in which the over-drawn user interface source codes exist and included in the over-drawing information with the document name corresponding to the non-inspection source codes in a pre-established non-inspection view list;
matching the position of the over-drawn user interface source code in the document with the position corresponding to the non-inspection source code in the non-inspection view list;
matching the path of the document with the over-drawn user interface source codes in the over-drawing information with the document path corresponding to the non-inspection source codes in the non-inspection view list.
In some optional embodiments, the method further includes:
and when no over-drawing information failed to be matched exists, packaging the source code file of the application program to generate 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 a check result of executing preset check on the source code file of the application program;
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 the over-drawing information of the over-drawn user interface source code included in the application program source code according to the character string searched by the searching module.
In some optional embodiments, the obtaining module is specifically configured to:
and acquiring a check result of performing static code analysis on the data in the specified directory of the source code file of the application program.
In some optional embodiments, the apparatus further comprises:
the second matching module is used for matching the over-drawing information matched by the first matching module with a pre-established inspection-free view list; if the matching is successful, ignoring the over-drawing information; and if the matching fails, writing the over-drawing information into an over-drawing report.
In a third aspect, an embodiment of the present invention provides a computer-readable storage medium, on which computer instructions are stored, and when the instructions are executed by a processor, the method for detecting overdraw of a user interface is implemented.
In a fourth aspect, an embodiment of the present invention provides a detector, including: the system comprises a memory, a processor and a computer program which is stored on the memory and can run on the processor, and is characterized in that the processor realizes the detection method of 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:
obtaining a checking result of executing preset checking on the source code file of the application program; and searching a preset character string from the checking result, and matching the over-drawing information of the over-drawn user interface source code included in the application program source code according to the searched character string. The method can automatically detect the condition that the user interface of the application program is excessively drawn, manual intervention is not needed, the labor cost is saved, and manual operation errors are avoided, so that the detection efficiency and the accuracy are greatly improved; the method can help research and development personnel to find the problem of excessive drawing more conveniently and more accurately, saves memory resources and improves 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 hereof as well as the appended drawings.
The technical solution of the present invention is further described in detail by the accompanying drawings and embodiments.
Drawings
The accompanying drawings, which are included to provide a further understanding of the invention and are incorporated in and constitute a part of this specification, illustrate embodiments of the invention and together with the description serve to explain the principles of the invention and not to limit the invention. In the drawings:
fig. 1 is a flowchart of a method for detecting overdrawing of a user interface according to a first embodiment of the present invention;
fig. 2 is a flowchart of a specific implementation of the detection method for detecting overdrawing of the user interface according to the second embodiment of the present invention;
fig. 3 is a schematic structural diagram of a detection apparatus for detecting an over-rendering of a user interface according to an embodiment of the present 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 of over-drawing wastes time and labor and is prone to errors in the prior art, the embodiment of the invention provides a detection method and device for over-drawing of a user interface, which can automatically detect over-drawing, save labor cost and improve detection efficiency and accuracy.
Example one
An embodiment of the present invention provides a method for detecting overdrawing of a user interface, where a flow of the method is shown in fig. 1, and the method includes the following steps:
step S11: and acquiring a checking result of executing preset checking on the source code file of the application program.
Specifically, the check result of performing static code analysis on the data in the specified directory of the source code file of the application program may be obtained.
For example, an Android packaging platform, that is, a platform for compiling and packaging an Android application source code file to generate an Android installation Package (Android Package, apk), often executes a linet check on source codes included in all files in a root directory of the application after the application source code file is compiled and before the application source code file is packaged, and outputs a check result, so that a developer finds and modifies corresponding problems in the application source code until there is no problem in the check result, or when it is determined that the problems in the check result can be ignored, compiles and packages the application source code file to generate the Android installation Package. The check result generated in the process includes the check result of the over-drawing aspect of each user interface source code, so that the check result is obtained, and the over-drawing detection can be performed on the user interface source codes in the application program source codes.
Optionally, the check result in the above process may also be a check result of the android packaging platform performing the lint check in another directory of the application source code file.
The static code analysis described above enables checking for bugs, optimizability, 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 inspection results generated by the linet inspection may contain a series of diagnostic information, including overdraw information. Optionally, if only the information of the over-rendering aspect of the source code needs to be known, only the inspection of the over-rendering aspect may be performed.
Optionally, the inspection result of the preset inspection performed on the application source code file by another packaging platform or a static code analysis tool may also be obtained, as long as the inspection result includes overdraw information.
Step S12: and searching a preset character string from the checking result, and matching the over-drawing information of the over-drawn user interface source code included in the application program source code according to the searched character string.
Specifically, the overdraw information includes a document name where the overdraw user interface source code exists, a position in the document where the overdraw user interface source code exists, and a path of the document where the overdraw user interface source code exists. The document can be found according to the path of the document where the over-drawn source codes exist and the name of the document where the over-drawn source codes exist, and then the specific content of the over-drawn source codes can be determined according to the position of the over-drawn source codes in the document where the over-drawn source codes exist.
Optionally, the overdraw information may further include: there is over-rendered user interface source code and over-rendered description information.
Taking the example that the check result is the check result of the android packaging platform performing the lint check on the data in the root directory of the source code file of the application program. The preset character string may be: id ═ overlaw; correspondingly, the overdrawing information of the user interface source code included in the application source code matched according to the searched character string may be: and searching the nearest preset corresponding character string behind each searched character string from the searched character string, and matching corresponding overdrawing information according to the searched character string and the corresponding character string.
Obtaining a checking result of executing preset checking on the source code file of the application program; and searching a preset character string from the checking result, and matching the over-drawing information of the over-drawn user interface source code included in the application program source code according to the searched character string. The method can automatically detect the condition that the user interface of the application program is excessively drawn, manual intervention is not needed, the labor cost is saved, and manual operation errors are avoided, so that the detection efficiency and the accuracy are improved; the method can help research and development personnel to find the problem of excessive drawing more conveniently and more accurately, saves memory resources and improves the user experience of the application program.
Optionally, after the overdrawing information of the user interface source code included in the application source code is matched according to the searched character string, all the overdrawing information may be written into the overdrawing report.
Or, all overdrawing information may be screened according to a preset rule, and the screened overdrawing information may be written in the overdrawing report.
Specifically, all over-drawn information is screened according to a preset rule, and the over-drawn information may be matched with a pre-established inspection-free view list; if the matching is successful, ignoring over-drawing information; and if the matching fails, writing the overdraw information into the overdraw report.
Specifically, matching the overdraw information with the pre-established inspection-free view list may include performing at least one of the following:
1. and matching the document name of the over-drawn user interface source code included in the over-drawing information with the document name corresponding to the non-inspection source code in the pre-established non-inspection view list.
2. And matching the position of the over-drawn user interface source code in the document with the position corresponding to the non-inspection source code in the non-inspection view list.
3. And matching the path of the document in which the over-drawn user interface source codes exist and included in the over-drawing information with the path of the document corresponding to the non-inspection source codes in the non-inspection view list.
Specifically, the review-free view list may be updated in real time, for example, the source code of the automatic monitoring application may be updated, and when the source code is updated, the overdraw information in the review-free view list is adaptively updated, including the change of the content of the overdraw information, and also including the deletion or addition of the review-free overdraw information. Specifically, the alteration of the content of the non-inspection overdraw information may be performed automatically; the addition or deletion may be performed interactively with the developer, for example: and popping up a pop-up window for adding the inspection-free over-drawn information, wherein the specific content of the added inspection-free over-drawn information is displayed for a developer to read, and simultaneously displaying whether an added prompt statement and two selection buttons of 'yes' and 'no', if yes, adding the inspection-free over-drawn information into the inspection-free over-drawn information, and if no, ignoring.
And matching each item of over-drawing information with the inspection-free over-drawing information, and writing the over-drawing information into an over-drawing report if the matching fails. The method avoids that some negligible over-drawing information in the inspection result is also recorded in the over-drawing report, so that research and development personnel do not need to perform secondary manual screening when reading the generated report, and time and labor are saved.
In some alternative embodiments, when there is no over-rendering information that fails to match, the application source code file may be packaged to generate an installation package of the application.
Example two
The second embodiment of the present invention provides a specific implementation of the method for detecting overdrawing of the user interface, where the obtained check result is a check result of performing a lint check on data in the root directory of the source code file of the application program, and a flow of the method is shown in fig. 2, and the method includes the following steps:
step S21: and obtaining a checking result of the android packaging platform for executing the lint check on the data under the source code file root directory of the application program.
In the prior art, in the process of compiling and packaging an application source code file, an android packaging platform automatically executes a gradew link command on data under a root directory of the application source code file after compiling and before packaging, performs link check, and automatically generates a check result, i.e., a link-results.xml file, in a reports directory under a built directory.
Step S22: and analyzing the overdraw information from the inspection result.
One item of overdraw information parsed from the inspection result may be as follows:
<issue id＝"Overdraw"；severity＝"Warning"；message＝"Possibleoverdraw:……"；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 over-drawing information comprises the name of the document where the over-drawn source code exists, the position in the document and the path of the document where the over-drawn source code exists
Each question in the examination results is labeled as an issue, with the id number indicating the category of the question, or the identification of the question, and the priority of the link examination, i.e., its severity, being set after the id number. And the specific line of source codes has problems and is positioned to the specific problem, so that developers can read and know the problem, rewrite the source codes and ensure the code quality when the source codes of the application program are finally on line.
The id after the issue is "Overdraw", which indicates Overdraw information, and the Overdraw information is taken as an example, and includes: safety: reminding; message: possibly an over-drawn item; the category: displaying; priority (severity level): 3; and (3) abstract: has been drawn more than once; description is given; document names where over-drawn source codes exist: xml, activity _ main; the position in the document where the over-drawn source code exists: line is "9", column is "5"; there is a path of the document where the over-drawn source code is located: /Users/roc/lab/MyAlg/app/src/main/res/layout/.
Specifically, the Overdraw information is analyzed from the inspection result, and a preset character string id may be searched from the inspection result; starting from each found string of character strings id ═ overlaw', searching the nearest preset corresponding character string </issue > behind the string, and matching corresponding over-drawing information, such as the above-mentioned over-drawing information, according to the found character string and the corresponding character string.
Step S23: and matching the analyzed overdrawing information with a pre-established inspection-free view list.
Taking the overdraw information exemplified in step S22 as an example, at the same time, matching the document name activity _ main.xml where the overdraw information is located, the start position line in the located document being "9", column being "5", the relative path src/main/res/layout/of the located document with the above-mentioned content of one item of overdraw information in the inspection-free white list, and if all the contents match, indicating that the matching is successful; at least one mismatch is present, indicating a failure to match.
If the matching is successful, go to step S24; if the matching fails, step S25 is executed.
Step S24: overdraw information is ignored.
If the matching is successful, the overdrawn information is free from inspection. Listed in the non-checked view list is a list of special xml views that need to be ignored, which, although they find the problem of over-rendering, are selected for omission for necessary or more complex view effects. Therefore, overdraw information matching the free-view list is ignored.
Step S25: the overdraw information is written to the overdraw report.
Step S26: an overdraw report is generated.
The generated overdraw report is directly displayed to the client, or sent to a specified mail or stored in a specified directory.
Based on the same inventive concept, an embodiment of the present invention further provides a detection apparatus for detecting an over-drawing interface, where the structure of the detection apparatus is shown in fig. 3, and the detection apparatus includes:
an obtaining module 31, configured to obtain a check result of performing a preset check on the source code file of the application;
a searching module 32, configured to search a preset character string from the inspection result obtained by the obtaining module 31;
the first matching module 33 is configured to match, according to the character string found by the finding module 32, overdraw information of the user interface source code included in the application source code, where the overdraw information includes the overdraw source code and the document in which the source code is located, the position in the document in which the source code is located, the path of the document in which the source code is located, and overdraw description information.
In some optional embodiments, the obtaining module 31 is specifically configured to:
and acquiring a check result of performing static code analysis on the data in the specified directory of the source code file of the application program.
In some optional embodiments, the apparatus further comprises:
a second matching module 34, configured to match the overdraw information matched by the first matching module 33 with a pre-established inspection-free view list; if the matching is successful, ignoring the over-drawing information; and if the matching fails, writing the over-drawing information into an over-drawing report.
In some optional embodiments, the second matching module 34 is specifically configured to:
performing at least one of:
matching the name of the document with the over-drawn source code included in the over-drawing information with the document name corresponding to the non-inspection source code in a pre-established non-inspection view list;
matching the position of the over-drawn source code in the document with the over-drawn source code included in the over-drawn information with the position corresponding to the non-inspection source code in the non-inspection view list;
and matching the path of the document with the over-drawn source code included in the over-drawing information with the document path corresponding to the non-inspection source code in the non-inspection view list.
In some optional embodiments, the apparatus further comprises:
and the packaging module 35 is configured to package the application program source code file and generate an installation package of the application program when there is no over-rendering information with failed matching.
With regard to the apparatus in the above-described embodiment, the specific manner in which each module performs the operation has been described in detail in the embodiment related to the method, and will not be elaborated here.
Based on the same inventive concept, the embodiment of the present invention further provides a computer-readable storage medium, on which computer instructions are stored, and when the instructions are executed by a processor, the method for detecting the overdraw of the user interface is implemented.
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 which is stored on the memory and can run on the processor, wherein the processor realizes the detection method for 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 and 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 is an example of exemplary approaches. Based upon 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 intended 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 the detailed description, with each claim standing on its own as a separate preferred embodiment of the 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. Of course, the storage medium may also be integral to the processor. The processor and the storage medium may reside in an ASIC. The ASIC may reside in a user terminal. Of course, 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. The 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.
What has been described above 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, to the extent that the term "includes" is used in either the detailed description or the claims, such term is intended to be inclusive in a manner similar to the term "comprising" as "comprising" is 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 a "non-exclusive or".
Claims (10)
1. A method for detecting overdraw of a user interface, comprising:
obtaining a checking result of executing preset checking on the source code file of the application program;
and searching a preset character string from the checking result, and matching out the over-drawing information of the over-drawn user interface source code according to the searched character string.
2. The method of claim 1, wherein obtaining inspection results for performing a predetermined inspection on the application source code file comprises:
and acquiring a check result of performing static code analysis on the data in the specified directory of the source code file of the application program.
3. The method of claim 1, wherein the overdraw information comprises:
and the document name of the over-drawn user interface source code, the position of the over-drawn user interface source code in the document and the path of the over-drawn user interface source code in the document are determined.
4. The method of claim 3, wherein after matching the over-rendering information of the over-rendered user interface source code included in the application source code according to the found character string, the method further comprises:
matching the over-drawing information with a pre-established inspection-free view list;
if the matching is successful, ignoring the over-drawing information;
and if the matching fails, writing the over-drawing information into an over-drawing report.
5. The method of claim 4, wherein matching overdraw information with a pre-established list of exempt views comprises performing at least one of:
matching the name of the document in which the over-drawn user interface source codes exist and included in the over-drawing information with the document name corresponding to the non-inspection source codes in a pre-established non-inspection view list;
matching the position of the over-drawn user interface source code in the document with the position corresponding to the non-inspection source code in the non-inspection view list;
matching the path of the document with the over-drawn user interface source codes in the over-drawing information with the document path corresponding to the non-inspection source codes in the non-inspection view list.
6. The method of claim 4, further comprising:
and when no over-drawing information failed to be matched exists, packaging the source code file of the application program to generate an installation package of the application program.
7. A user interface overdraw detection apparatus, comprising:
the acquisition module is used for acquiring a check result of executing preset check on the source code file of the application program;
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 the over-drawing information of the over-drawn user interface source code included in the application program source code according to the character string searched by the searching module.
8. The apparatus of claim 7, wherein the obtaining module is specifically configured to:
and acquiring a check result of performing static code analysis on the data in the specified directory of the source code file of the application program.
9. A computer readable storage medium having stored thereon computer instructions, which when executed by a processor, implement a method for detecting overdraw in a user interface as claimed in any one of claims 1 to 6.
10. A detector, comprising: memory, processor and computer program stored on 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 one of claims 1 to 6 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 true CN111611153A (en) | 2020-09-01 |
| CN111611153B 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 (7)
| 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 |
| JP2007179488A (en) * | 2005-12-28 | 2007-07-12 | Fujitsu Ltd | Source code problem prediction program |
| 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 |
| US20170329701A1 (en) * | 2016-05-16 | 2017-11-16 | Google Inc. | Application Pre-Release Report |
| CN109063477A (en) * | 2018-07-18 | 2018-12-21 | 成都链安科技有限公司 | A kind of intelligent contract aacode defect detection system and method for automation |
-
2019
- 2019-02-26 CN CN201910140858.0A patent/CN111611153B/en active Active
Patent Citations (7)
| 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 |
| JP2007179488A (en) * | 2005-12-28 | 2007-07-12 | Fujitsu Ltd | Source code problem prediction program |
| 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 |
| US20170329701A1 (en) * | 2016-05-16 | 2017-11-16 | Google Inc. | Application Pre-Release Report |
| 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 |
|---|---|
| CN111611153B (en) | 2023-05-16 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US8943423B2 (en) | User interface indicators for changed user interface elements | |
| US8966449B2 (en) | Test case pattern matching | |
| US9064057B2 (en) | Processing automation scripts of software | |
| US9152731B2 (en) | Detecting a broken point in a web application automatic test case | |
| US8386851B2 (en) | Functional coverage using combinatorial test design | |
| US20080244536A1 (en) | Evaluating static analysis results using code instrumentation | |
| US9311217B2 (en) | Analyzing computer programs to identify errors | |
| KR101892206B1 (en) | Bidirectional text checker | |
| WO2009095741A1 (en) | Selective code instrumentation for software verification | |
| CN107045477B (en) | Quality assessment platform capable of carrying out multi-dimensional detection | |
| US7369129B2 (en) | Automated user interface testing | |
| CN116991736A (en) | Static code analysis method, device, system and storage medium | |
| US9563541B2 (en) | Software defect detection identifying location of diverging paths | |
| US8930765B2 (en) | Systems and methods for feedback driven regression testing | |
| US9298584B2 (en) | Artifact selection using textual reports | |
| CN115794638A (en) | Test method, system and computer equipment based on code change analysis engine | |
| US8589342B2 (en) | Log message optimization to ignore or identify redundant log messages | |
| US8464103B2 (en) | Generating a functional coverage model from a trace | |
| CN111611153B (en) | Method and device for detecting overdrawing of user interface | |
| CN117667716A (en) | Page testing method and device and electronic equipment | |
| US10127202B2 (en) | Detecting overlapping web elements in a graphical user interface | |
| US20050235266A1 (en) | System and method for business rule identification and classification | |
| US20150199183A1 (en) | Program analysis apparatus and program analysis method | |
| US20150212993A1 (en) | Impact Coverage | |
| Khalil | Design and Evaluation of an AI-Driven Workflow for Technical Debt Remediation in Software Systems |
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 |