CN108121650B - Method and device for testing page user interface - Google Patents
Method and device for testing page user interface Download PDFInfo
- Publication number
- CN108121650B CN108121650B CN201611085397.4A CN201611085397A CN108121650B CN 108121650 B CN108121650 B CN 108121650B CN 201611085397 A CN201611085397 A CN 201611085397A CN 108121650 B CN108121650 B CN 108121650B
- Authority
- CN
- China
- Prior art keywords
- application client
- test
- main program
- executed
- page
- 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/3668—Software testing
- G06F11/3672—Test management
- G06F11/3684—Test management for test design, e.g. generating new test cases
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3688—Test management for test execution, e.g. scheduling of test suites
Abstract
The application provides a method for testing a page User Interface (UI), which comprises the following steps: determining a target application client main program to find an entry function of the target application client main program; injecting a jump instruction related to the entry function into the main program, so that when the main program is executed, a sub-function under the entry function is executed; installing a main program to generate a test application client; when the page UI test is carried out, the application client terminal for the test is operated, wherein when the jump instruction is executed, the subfunction is executed, so that the application client terminal for the test starts a browser kernel of an operating system to render the page; and connecting the computing equipment provided with the UI testing tool supporting the browser kernel of the operating system, so that the UI testing tool positions the page UI elements for automatic testing. The application also provides a corresponding device. By adopting the scheme provided by the application, the automatic test performance of the page UI can be improved.
Description
Technical Field
The present disclosure relates to the field of Information Technology (IT), and in particular, to a method and an apparatus for testing a User Interface (UI) of a page.
Background
With the development of internet technology, a lot of services such as city services on application clients (APPs) such as WeChat, qq or Payment treasures, which load hypertext markup language (HTML) pages (such as H5 pages) in some APPs, and after the city services such as registration are opened, the APPs actually carry the corresponding page services. Because the number of page services is increasing, testers need to perform automatic testing of HTML page services on a test terminal, for example, a UI automatic testing method such as Appium + uutomator may be used, and at this time, an automatic testing tool such as uautotom viewer needs to be used to analyze a UI component to obtain page UI elements. However, due to some application clients, such as WeChat, the browser kernel on which the application depends is not the browser kernel of the operating system (such as Webview kernel of android system), but other browser kernels, such as: WeChat uses the X5 browser kernel for HTML page rendering. However, the automated testing tool of uaiautomatorviewer supports the browser kernel of the operating system, and the application client using the browser kernel of the non-operating system for page rendering cannot use the testing tool of uautomatorviewer to locate the page UI elements.
Disclosure of Invention
The application provides a method for testing a page User Interface (UI), which comprises the following steps: determining a target application client main program to find an entry function of the target application client main program; injecting a jump instruction related to the entry function into the main program, so that when the main program is executed, a sub-function under the entry function is executed; installing the main program to generate a test application client; when the page UI test is performed, the following processing is performed: running the test application client, wherein when the jump instruction is executed, the sub-function is executed, causing the test application client to enable a browser kernel of an operating system to render a page; and connecting the computing equipment provided with the UI testing tool supporting the browser kernel of the operating system, so that the UI testing tool positions page UI elements for automatic testing.
The present application also proposes an apparatus for testing a page User Interface (UI), comprising: the determining module is used for determining a main program of the target application client to find an entry function of the target application client; the injection module is used for injecting a jump instruction related to the entry function into the main program, so that when the main program is executed, a sub-function under the entry function of the main program is executed; the running module is used for installing the main program to generate a test application client; when the page UI test is performed, the following processing is performed: running the test application client, wherein when the jump instruction is executed, the sub-function is executed, causing the test application client to enable a browser kernel of an operating system to render a page; and connecting the computing equipment provided with the UI testing tool supporting the browser kernel of the operating system, so that the UI testing tool positions page UI elements for automatic testing.
By adopting the method and the device provided by the application, the aim of positioning the page element by using the UI test tool supporting the browser kernel of the operating system can be fulfilled, so that the automatic test of the page UI is realized.
Drawings
In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below, and it is obvious that the drawings in the following description are only some embodiments of the present invention, and for those skilled in the art, other drawings can be obtained according to these drawings without creative efforts.
FIG. 1 is an example of an inability to locate UI page elements in an example of the present application;
FIG. 2 is a flow diagram of a method for testing a page User Interface (UI) according to an example of the present application;
FIG. 3 is an example of successfully navigating to UI page elements in an example of the present application;
FIG. 4 is an example program implementing a method for testing a page User Interface (UI) according to an example of the present application;
FIG. 5A is a diagram of an apparatus according to an embodiment of the present application;
FIG. 5B is a block diagram of an operational block 503 of an apparatus according to an example of the present application;
fig. 6 is a hardware configuration diagram of a device according to an example of the present application.
Detailed Description
The technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are only a part of the embodiments of the present invention, and not all of 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 invention.
For simplicity and clarity of description, the invention will be described below by describing several representative embodiments. The numerous details of the examples are merely provided to assist in understanding the inventive arrangements. It will be apparent, however, that the invention may be practiced without these specific details. Some embodiments are not described in detail, but rather are merely provided as frameworks, in order to avoid unnecessarily obscuring aspects of the invention. Hereinafter, "including" means "including but not limited to", "according to … …" means "at least according to … …, but not limited to … … only". When the number of one component is not particularly specified hereinafter, it means that the component may be one or more, or may be understood as at least one.
As mentioned above, some automated testing tools support the browser kernel of the operating system, and such terminal applications that use the browser kernel of the non-operating system for page rendering cannot use these testing tools to locate the UI elements of the page, for example, in the H5 service of wechat, open a registration service, click on a department in the middle, for example, the traditional chinese medical department 101, and cannot locate the UI component 102 corresponding to a specific department, as shown in fig. 1.
The application provides a method for testing a page User Interface (UI) (hereinafter, referred to as page UI), which can be applied to a test terminal, and can be various terminal devices, such as: various handheld devices such as mobile phones and tablets, wearable devices, PCs and the like. These end devices may be based on various operating system platforms, such as: android (android) systems, IOS systems, Windows systems, etc.
As shown in fig. 2, the method comprises the steps of:
step 201: the main program of the target application client is determined to find the entry function thereof.
Here, the source code of the main program is determined from the source codes of the application programs installed in the test terminal, and the entry function is found therein.
Generally, various application clients, such as WeChat, QQ, etc., are installed on the test terminal, wherein the target application client may be a software program installed on the test terminal. In the test terminal, the main program of all the application client software programs respectively has an entry function, the entry function is the main function of the main program, the entry function is executed firstly when the main program is executed, and a plurality of sub-functions are included below the entry function and are respectively used for realizing different functions.
In some examples, in order to determine the main program of the target application client, Root needs to be performed on the test terminal, and the super-user permission is acquired, so as to allow the super-user operation to be performed on the test terminal. And installing a cracking frame application program, such as XposedIndusttaler, on the test terminal to take over certain functions of the test terminal system, and further giving more permissions to a target application client on the test terminal to complete modification of the main program of the target application client.
In some examples, the installation package of the target application client is downloaded, the cracking frame application program is used for cracking the installation package, and the source code of the target application client is obtained so as to determine the main program of the target application client.
In some examples, the cracking frame application program traverses source codes of all application client side main programs installed on the test terminal, and if the name of the found application client side main program is not equal to the name of the target application client side main program, a null value is returned, and the searching is continued; and if the name of the found application client side main program is equal to the name of the target application client side main program, indicating that the target application client side main program is found.
Step 202: and injecting a jump instruction related to the entry function into the main program, so that when the main program is executed, a sub-function under the entry function of the main program is executed.
In some instances, the injected jump instruction may be a Hook (Hook) function that may be used to Hook events or messages that occur at their target. The most common is a mouse and a keyboard Hook, the mouse and the keyboard are hooked by the Hook, and when any operation is performed on the mouse and the keyboard, the operation can be known through the Hook. When the entry function of the main program of the target application client is found, a function to be Hook is found, and a Hook code can be added into the function.
Furthermore, the purpose of the Hook function is to Hook to another function when calling its target function, where the entry function of the main program, such as the oncreate function, is the target function of the Hook function, and the Hook function is executed without changing the original logic of the entry function, and when the main program is executed, a sub-function under the entry function is executed after hooking the entry function.
Step 203: and installing the main program to a test terminal to generate a test application client.
In this step, the main program injected with the jump instruction is packaged into an executable file, such as an apk file, and installed on the test terminal to generate a new application client, i.e., a test application client.
Step 204: running the test application client, wherein when the jump instruction is executed, the sub-function is executed, such that the test application client launches a browser kernel of an operating system to render a page.
In some examples, running the test application client further includes: selecting the application client for testing from the installed application programs provided by the cracking framework application program on the testing terminal, and loading the application client for testing when the testing terminal is restarted; the test terminal logs in the kernel configuration entry of the target application client and sets the state of forcibly using the system kernel switch in a logged page as an open state, wherein the kernel configuration entry of the target application client is a preset address, such as a website for debugging Tencent X5 kernel servicehttp://debugtbs.qq.com(ii) a And restarting the test terminal, and loading and operating the application client for testing.
In some examples, when the test application client is running, the jump instruction is executed, and the sub-function is executed, so that the test application client is forced to render a page using a browser kernel of an operating system of the test terminal.
Step 205: and connecting the computing equipment provided with the UI testing tool supporting the browser kernel of the operating system, so that the UI testing tool positions page UI elements for automatic testing.
In some examples, step 204 renders the page with the browser kernel of the operating system, so that the UI elements of the page can be identified and located by the UI test tool of the browser kernel supporting the operating system; the test terminal is connected with a computing device, such as a PC, a tablet and the like, a UI test tool of the browser kernel supporting the operating system is opened on the computing device, and page UI elements are successfully positioned and displayed. For example, in the WeChat H5 service, open WeChat-City service-registration platform-certain hospital-select a certain department, such as "postpartum disease expert in TCM" 301, and PC end-point clicks the test tool icon, so that the lower page element 302 can be displayed, such as "infertility in TCM", as shown in FIG. 3.
According to the technical scheme, the main program of the target application client is determined, the jump instruction is injected, the application client for testing can use the browser kernel of the operating system to render the page when running, the purpose of positioning the page element by using the UI testing tool supporting the browser kernel of the operating system is finally achieved, and further the automatic testing of the page UI can be achieved by using the UI testing tool.
Fig. 4 shows an example of a program, which includes several examples of programs that implement the following functions: determining a main program of a target application client, setting the target application client to be in an adjustable mode, setting a Hook entry function, and opening a sub-function under the entry function to modify a page rendering mode (namely setting a browser kernel adopted by page rendering).
Based on the above method examples, the present application also proposes an apparatus for testing a page UI, as shown in fig. 5A, the apparatus includes a determining module 501, an injecting module 502, and an operating module 503.
In some examples, the functions of the modules are as follows:
a determining module 501, configured to determine a target application client main program to find an entry function thereof; setting the main program to be a debugging mode;
an injecting module 502, configured to inject a jump instruction related to the entry function into the main program, so that when the main program is executed, a sub-function under the entry function of the main program is executed;
a running module 503, configured to install the main program into the test terminal to generate a test application client; running the test application client, wherein when the jump instruction is executed, the sub-function is executed, causing the test application client to enable a browser kernel of an operating system to render a page; and positioning the page UI element by utilizing a UI testing tool of a browser kernel supporting the operating system so as to carry out automatic testing.
The operation module 503 further includes a mounting unit, an operation unit, and a connection unit, as shown in fig. 5B, the functions of each unit are as follows:
an installation unit 5031, configured to install the main program to generate a test application client.
A running unit 5032, configured to run the test application client, where when the jump instruction is executed, the sub-function is executed, so that the test application client enables a browser kernel of an operating system to render a page.
A connecting unit 5033, configured to connect the test terminal to a computing device, and locate a page UI element by using a UI test tool of a browser kernel supporting the operating system on the computing device to perform an automated test. Wherein, the computing device can be a PC or a tablet computer.
The specific method and principle for implementing various functions by the above modules are described in the foregoing, and are not described herein again. The modules may be located in one computing device or may be distributed in a plurality of computing devices.
In addition, the devices and modules in the examples of the present application may be integrated into one processing unit, or each module may exist alone physically, or two or more devices or modules may be integrated into one unit. The integrated unit can be realized in a form of hardware, and can also be realized in a form of a software functional unit.
In an embodiment, the testing apparatus may be run in any computing device for media push control, and loaded in a memory of the computing device. As shown in fig. 6, the computing apparatus may include, in addition to the respective modules in the control device described above: memory 611, processor 613, bus 612, port 614. The processor 613 and the memory 611 are interconnected by a bus 612. Processor 613 can receive and transmit data through port 614 to enable network communications and/or local communications. Each of the modules 501-503 may be machine-executable instruction modules stored in the memory 611. The processor 613 can further implement the functions of the modules 501 to 503 by executing machine-executable instructions included in the modules 501 to 503 in the memory 611.
In addition, each example of the present application can be realized by a data processing program executed by a data processing apparatus such as a computer. It is clear that the data processing program constitutes the invention. Further, a data processing program, which is generally stored in one storage medium, is executed by directly reading the program out of the storage medium or by installing or copying the program into a storage device (such as a hard disk and/or a memory) of the data processing device. Such a storage medium therefore also constitutes the present invention. The storage medium may use any type of recording means, such as a paper storage medium (e.g., paper tape, etc.), a magnetic storage medium (e.g., a flexible disk, a hard disk, a flash memory, etc.), an optical storage medium (e.g., a CD-ROM, etc.), a magneto-optical storage medium (e.g., an MO, etc.), and the like.
The present application thus also provides a non-volatile storage medium having stored therein a data processing program for executing any one of the examples of the method of the present application.
The above description is only for the purpose of illustrating the preferred embodiments of the present invention and is not to be construed as limiting the invention, and any modifications, equivalents, improvements and the like made within the spirit and principle of the present invention should be included in the scope of the present invention.
Claims (12)
1. A method for testing a page user interface, UI, performed by a test terminal, the method comprising:
determining a target application client main program to find an entry function of the target application client main program;
injecting a jump instruction related to the entry function into the main program, so that when the main program is executed, a sub-function under the entry function is executed;
installing the main program to generate a test application client, wherein the browser kernel on which the test application client depends is not the browser kernel of the operating system;
when the page UI test is performed, the following processing is performed:
running the test application client, wherein when the jump instruction is executed, the sub-function is executed such that the test application client enables a browser kernel of the operating system to render a page; and
and connecting the computing equipment provided with the UI testing tool supporting the browser kernel of the operating system, so that the UI testing tool positions page UI elements for automatic testing.
2. The method of claim 1, wherein the determining a target application client primary program comprises:
installing and cracking the frame application program; and
and traversing the main programs of all the application clients by using the cracking frame application program, and determining the main programs of the target application clients.
3. The method of claim 2, further comprising: root is carried out on the test terminal, and super user permission is obtained so as to allow the cracking frame application program to be installed to debug and modify the main program;
downloading the installation package of the target application client; and
and the cracking frame application program is utilized to crack the installation package and obtain the source code of the target application client so as to determine the source code of the main program and inject the jump instruction into the source code.
4. The method of claim 1, wherein said injecting a jump instruction in the main program with the entry function comprises:
finding an entry function of the main program; and
and adding the jump instruction according to the entry function, so that when the main program is executed, the jump instruction hooks the entry function, so that the sub-function is executed, and a browser kernel of the operating system is enabled to render a page.
5. The method of claim 2, wherein the running the test application client comprises:
selecting the application client for testing from the installed application programs provided by the cracking framework application program;
logging in a kernel configuration entry of a target application client, and setting a state of a browser kernel switch which forcibly uses an operating system as an open state; and
restarting the test terminal, loading and running the application client for test,
and the kernel configuration entry is a preset address.
6. An apparatus for testing of a page UI, the apparatus comprising:
the determining module is used for determining a main program of the target application client to find an entry function of the target application client;
the injection module is used for injecting a jump instruction related to the entry function into the main program, so that when the main program is executed, a sub-function under the entry function of the main program is executed;
the running module is used for installing the main program to generate a test application client, and a browser kernel on which the test application client depends is not a browser kernel of an operating system; when the page UI test is performed, the following processing is performed: running the test application client, wherein when the jump instruction is executed, the sub-function is executed such that the test application client enables a browser kernel of the operating system to render a page; and connecting the computing equipment provided with the UI testing tool supporting the browser kernel of the operating system, so that the UI testing tool positions page UI elements for automatic testing.
7. The apparatus of claim 6, wherein the determining module is configured to install a cracking framework application, and to traverse the main programs of all application clients using the cracking framework application to determine the target application client main program.
8. The apparatus of claim 6, wherein the injection module finds an entry function of the main program; and adding the jump instruction according to the entry function, so that when the main program is executed, the jump instruction hooks the entry function, so that the sub-function is executed, and a browser kernel of the operating system is enabled to render a page.
9. The apparatus of claim 7, wherein the operation module comprises:
the installation unit is used for installing the main program to generate a test application client;
a running unit, configured to run the test application client, wherein when the jump instruction is executed, the sub-function is executed, so that the test application client enables a browser kernel of an operating system to render a page;
and the connection unit is used for connecting the computing equipment provided with the UI test tool supporting the browser kernel of the operating system so as to enable the UI test tool to position the page UI element for carrying out automatic test.
10. The apparatus of claim 9, wherein the execution unit is configured to select the test application client from the installed applications provided by the cracking framework application; the test terminal logs in a kernel configuration inlet of a target application client and sets a browser kernel switch state which forcibly uses an operating system as an open state; and restarting the test terminal, and loading and running the application client for test, wherein the kernel configuration entry is a preset address.
11. A computing device comprising at least one processor and at least one memory, wherein the memory stores a computer program that, when executed by the processor, causes the processor to perform the method of any of claims 1-5.
12. A non-transitory storage medium having stored thereon machine readable instructions for causing at least one processor to perform the method of any one of claims 1 to 5.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201611085397.4A CN108121650B (en) | 2016-11-29 | 2016-11-29 | Method and device for testing page user interface |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201611085397.4A CN108121650B (en) | 2016-11-29 | 2016-11-29 | Method and device for testing page user interface |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN108121650A CN108121650A (en) | 2018-06-05 |
| CN108121650B true CN108121650B (en) | 2020-06-19 |
Family
ID=62226291
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201611085397.4A Active CN108121650B (en) | 2016-11-29 | 2016-11-29 | Method and device for testing page user interface |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN108121650B (en) |
Families Citing this family (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109032705B (en) * | 2018-07-05 | 2022-02-25 | 腾讯科技（深圳）有限公司 | Application program execution method and device, electronic equipment and readable storage medium |
| CN110704148B (en) * | 2019-09-20 | 2023-09-05 | 广州虎牙科技有限公司 | Acquisition method and device of equipment page element, server and storage medium |
| CN111026638A (en) * | 2019-10-29 | 2020-04-17 | 贝壳技术有限公司 | Webpage automatic testing method and device, electronic equipment and storage medium |
| CN111258912B (en) * | 2020-02-14 | 2023-01-10 | 苏州浪潮智能科技有限公司 | Page testing method, device, terminal and storage medium |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102722551A (en) * | 2012-05-26 | 2012-10-10 | 广州市动景计算机科技有限公司 | Intelligent switching method and system for browser kernels |
| CN103186459A (en) * | 2011-12-30 | 2013-07-03 | 迈普通信技术股份有限公司 | JAVA graphical user interface automatic test method based on scripts |
| CN104199711A (en) * | 2014-09-29 | 2014-12-10 | 北京奇虎科技有限公司 | Method and device for creating root access |
| CN105512044A (en) * | 2015-12-25 | 2016-04-20 | 北京奇虎科技有限公司 | Method and system for updating object base used for keyword drive test |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US8793662B2 (en) * | 2008-03-25 | 2014-07-29 | Microsoft Corporation | Runtime code hooking for print driver and functionality testing |
-
2016
- 2016-11-29 CN CN201611085397.4A patent/CN108121650B/en active Active
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103186459A (en) * | 2011-12-30 | 2013-07-03 | 迈普通信技术股份有限公司 | JAVA graphical user interface automatic test method based on scripts |
| CN102722551A (en) * | 2012-05-26 | 2012-10-10 | 广州市动景计算机科技有限公司 | Intelligent switching method and system for browser kernels |
| CN104199711A (en) * | 2014-09-29 | 2014-12-10 | 北京奇虎科技有限公司 | Method and device for creating root access |
| CN105512044A (en) * | 2015-12-25 | 2016-04-20 | 北京奇虎科技有限公司 | Method and system for updating object base used for keyword drive test |
Also Published As
| Publication number | Publication date |
|---|---|
| CN108121650A (en) | 2018-06-05 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US10642599B1 (en) | Preemptive deployment in software deployment pipelines | |
| US10120784B2 (en) | Test case generation for uncovered code paths | |
| US9977904B2 (en) | Systems and methods for automated detection of application vulnerabilities | |
| US20160371105A1 (en) | Deployment and installation of updates in a virtual environment | |
| US20150089299A1 (en) | Online application testing across browser environments | |
| CN108121650B (en) | Method and device for testing page user interface | |
| US10042744B2 (en) | Adopting an existing automation script to a new framework | |
| CN109669873B (en) | User interface automatic test method and device, electronic equipment and storage medium | |
| US11436131B2 (en) | Systems and methods for software testing using a disposable code | |
| US8826243B2 (en) | System, method, and computer program product for error code injection | |
| CN112799940A (en) | Regression testing method, device, computer system and computer readable storage medium | |
| KR20190113050A (en) | Method and system for automatic configuration test case generation of mobile application | |
| US20190121985A1 (en) | Detecting vulnerabilities in applications during execution | |
| Kurtz et al. | Dios: Dynamic privacy analysis of ios applications | |
| US10019344B1 (en) | Computer implemented system and method and computer program product for a test framework for orchestration workflows | |
| US9886367B2 (en) | Unified processing test structure | |
| CN112882921B (en) | Fault simulation method and device | |
| US20200142689A1 (en) | System And Methods for Patch Management | |
| CN112506781A (en) | Test monitoring method, test monitoring device, electronic device, storage medium, and program product | |
| CN111859403A (en) | Method and device for determining dependency vulnerability, electronic equipment and storage medium | |
| US20120131569A1 (en) | Automated solaris container creation | |
| US9697018B2 (en) | Synthesizing inputs to preserve functionality | |
| CN111740876B (en) | Application device, test method, storage medium and electronic equipment | |
| CN113760723B (en) | Business process debugging method and device | |
| JP7076014B2 (en) | Java Debugger blocking method and system for program protection |
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 |