CN116431465A

CN116431465A - Interface matching method and device, storage medium and electronic equipment

Info

Publication number: CN116431465A
Application number: CN202211718109.XA
Authority: CN
Inventors: 栗剑扬
Original assignee: Beijing Oceanbase Technology Co Ltd
Current assignee: Beijing Oceanbase Technology Co Ltd
Priority date: 2022-12-29
Filing date: 2022-12-29
Publication date: 2023-07-14

Abstract

The specification provides a method, a device, a storage medium and electronic equipment for interface matching, which are characterized in that through splitting the obtained identifiers of target interfaces, determining each target element and sequencing each target element, sequentially creating a tree structure corresponding to all target identifiers according to the sequencing result, when the interfaces to be matched are matched in each target interface, splitting the obtained identifiers of the interfaces to be matched, determining each element to be matched, sequencing each element to be matched, sequentially matching each element to be matched with the target element corresponding to each node in the tree structure according to the sequencing result, and determining the target interface matched with the interfaces to be matched in the target interfaces according to the matching result. According to the method, the tree structure is created, so that the elements to be matched can be more quickly matched with the target elements, the number of target interfaces matched with the interfaces to be matched in the target interfaces can be more quickly and conveniently determined, and the interface matching performance is greatly improved.

Description

Interface matching method and device, storage medium and electronic equipment

Technical Field

The present invention relates to the field of computers, and in particular, to a method and apparatus for interface matching, a storage medium, and an electronic device.

Background

With the development of internet technology, interface matching is often used in web testing, statistics, and the like.

Taking web test as an example, a common method is to match tested interfaces with interfaces to be tested one by one, and determine the number of interfaces matched with the tested interfaces in the interfaces to be tested, so as to obtain test coverage rate, for example, 100 interfaces to be tested, 20 tested interfaces are matched with the interfaces to be tested respectively, and it is determined that the number of interfaces successfully matched with the tested interfaces is 10 in 100 interfaces to be tested, and the test coverage rate is 10/100=10%, but for interfaces with larger orders of magnitude, the method consumes resources and has poor performance, and for interface websites containing variables, a method using accurate matching results are inaccurate, and fuzzy search matching cannot be realized.

Therefore, how to improve the performance of interface matching is a urgent problem to be solved.

Disclosure of Invention

The present disclosure provides a method, an apparatus, a storage medium, and an electronic device for interface matching, so as to at least partially solve the foregoing problems.

The technical scheme adopted in the specification is as follows:

the specification provides a method of interface matching, the method comprising:

acquiring identifiers of a plurality of target interfaces as target identifiers;

splitting the target identifier aiming at each target identifier to determine each target element composing the target identifier;

according to the sorting of all the target elements split from all the target identifiers in the target identifiers where the target elements are located, creating a tree structure corresponding to all the target identifiers, wherein each target element corresponds to one node in the tree structure, and the sorting of the target elements corresponding to the father node in the target identifiers is earlier than the sorting of the target elements corresponding to the child nodes in the target identifiers;

for each node of the tree structure, if the target element corresponding to the node is located at the last position in any target identifier, marking the node;

when the identification of the interface to be matched is obtained, splitting the identification of the interface to be matched, determining each element to be matched forming the identification of the interface to be matched, matching each element to be matched with the tree structure according to the sequence of each element to be matched in the identification of the interface to be matched, determining the node hit by the identification of the interface to be matched, and determining the interface to be matched as one of the target interfaces if the node hit by a leaf node or a marked node.

Optionally, according to the sorting of each target element split from all target identifiers in the target identifier where each target element is located, a tree structure corresponding to all target identifiers is created, which specifically includes:

ordering each target element of each target identifier aiming at each target identifier; each child node of the root node in the tree structure is used as a current node;

according to the sorting order, sequentially aiming at each target element of the target mark, and taking the target element as a current element;

judging whether nodes corresponding to the current elements exist in the current nodes or not;

if yes, each sub node of the current node corresponding to the current element in the tree structure is redetermined as the current node, the next element of the current element is redetermined as the current element according to the ordering sequence, and whether the redetermined node corresponding to the redetermined current element exists in each current node is continuously judged;

otherwise, creating a child node corresponding to the current element under the parent node of the current node, using the child node as a newly added node, re-determining each child node of the newly added node as the current node, re-determining the next element of the current element as the current element according to the sorting order, and continuously judging whether the re-determined nodes corresponding to the re-determined current element exist in each current node until the nodes corresponding to all target elements of the target identifier are determined in the tree structure.

Optionally, creating a child node corresponding to the current element specifically includes:

if the current element is a variable, generating a wild card matched with the variable, and generating a wild card condition corresponding to the wild card according to the variable;

creating a child node corresponding to the wild card as the created child node corresponding to the current element;

matching each element to be matched with the tree structure specifically comprises the following steps:

and when the element to be matched is a variable, searching a wild card symbol corresponding to the wild card condition matched with the element to be matched, and if a node corresponding to the searched wild card symbol exists in the tree structure, determining that the element to be matched is matched with the node corresponding to the searched wild card symbol.

Optionally, matching each element to be matched with the tree structure specifically includes:

sequencing all elements to be matched in the identification of the interface to be matched, and taking all child nodes of a root node in a tree structure as matching nodes;

according to the sorting order, sequentially aiming at each element to be matched, and taking the element to be matched as a current element;

judging whether nodes corresponding to the current element exist in the matching nodes or not;

If not, determining that a target interface matched with the interface to be matched does not exist in the plurality of target interfaces;

if so, redefining each sub-node of the matching node corresponding to the current element in the tree structure as a matching node, redefining the next element of the current element as the current element according to the sorting order, and continuously judging whether the redetermined node corresponding to the redetermined current element exists in each redetermined matching node until determining the node corresponding to the last element to be matched in the identification of the interface to be matched, and taking the node corresponding to the last element to be matched in the identification of the interface to be matched as the node hit by the identification of the interface to be matched.

Optionally, before searching for a wild card corresponding to the wild card condition matched with the element to be matched, the method further includes:

and determining that no corresponding element exists in the tree structure as the node of the element to be matched.

Optionally, the target interface is an interface to be tested;

the interface to be matched is an interface for completing the test;

the method further comprises the steps of:

and determining the test coverage rate and/or the test frequency of each target interface according to the number of the target interfaces matched with the interfaces to be matched in the determined target interfaces.

The present specification provides an apparatus for interface matching, the apparatus comprising:

the acquisition module is used for acquiring the identifiers of a plurality of target interfaces and taking the identifiers as target identifiers;

the determining module is used for splitting each target identifier and determining each target element composing the target identifier;

the creating module is used for creating a tree structure corresponding to all target identifiers according to the sequences of all target elements split from all target identifiers in the target identifiers where the target elements are located, wherein each target element corresponds to one node in the tree structure, and the sequence of the target elements corresponding to a father node in the target identifiers is earlier than the sequence of the target elements corresponding to a child node in the target identifiers;

the marking module is used for marking each node of the tree structure if the target element corresponding to the node is positioned at the last position in any target mark;

the matching module is used for splitting the identification of the interface to be matched when the identification of the interface to be matched is acquired, determining each element to be matched forming the identification of the interface to be matched, matching each element to be matched with the tree structure according to the sequence of each element to be matched in the identification of the interface to be matched, determining the node hit by the identification of the interface to be matched, and determining the interface to be matched to be one of the plurality of target interfaces if the node hit by a leaf node or a marked node.

Optionally, the creating module is specifically configured to sort, for each target identifier, each target element of the target identifier; each child node of the root node in the tree structure is used as a current node; according to the sorting order, sequentially aiming at each target element of the target mark, and taking the target element as a current element; judging whether nodes corresponding to the current elements exist in the current nodes or not; if yes, each sub node of the current node corresponding to the current element in the tree structure is redetermined as the current node, the next element of the current element is redetermined as the current element according to the ordering sequence, and whether the redetermined node corresponding to the redetermined current element exists in each current node is continuously judged; otherwise, creating a child node corresponding to the current element under the parent node of the current node, using the child node as a newly added node, re-determining each child node of the newly added node as the current node, re-determining the next element of the current element as the current element according to the sorting order, and continuously judging whether the re-determined nodes corresponding to the re-determined current element exist in each current node until the nodes corresponding to all target elements of the target identifier are determined in the tree structure.

Optionally, the creating module is specifically configured to generate a wild card matched with a variable if the current element is the variable, and generate a wild card condition corresponding to the wild card according to the variable; creating a child node corresponding to the wild card as the created child node corresponding to the current element;

the matching module is specifically configured to search for a wildcard identifier corresponding to a wildcard condition matched with an element to be matched when the element to be matched is a variable, and determine that the element to be matched is matched with a node corresponding to the searched wildcard identifier if a node corresponding to the searched wildcard identifier exists in the tree structure.

Optionally, the matching module is specifically configured to sort elements to be matched in the identifier of the interface to be matched, and take each child node of the root node in the tree structure as a matching node; according to the sorting order, sequentially aiming at each element to be matched, and taking the element to be matched as a current element; judging whether nodes corresponding to the current element exist in the matching nodes or not; if not, determining that a target interface matched with the interface to be matched does not exist in the plurality of target interfaces; if so, redefining each sub-node of the matching node corresponding to the current element in the tree structure as a matching node, redefining the next element of the current element as the current element according to the sorting order, and continuously judging whether the redetermined node corresponding to the redetermined current element exists in each redetermined matching node until determining the node corresponding to the last element to be matched in the identification of the interface to be matched, and taking the node corresponding to the last element to be matched in the identification of the interface to be matched as the node hit by the identification of the interface to be matched.

Optionally, before searching for a wild card identifier corresponding to a wild card condition that matches the element to be matched, the matching module is further configured to determine that no corresponding element in the tree structure is a node of the element to be matched.

Optionally, the target interface is an interface to be tested; the interface to be matched is an interface for completing the test; the matching module is further used for determining the test coverage rate and/or the test frequency of each target interface according to the number of the target interfaces matched with the interfaces to be matched in the determined target interfaces.

The present specification provides a computer readable storage medium storing a computer program which when executed by a processor implements the above-described method of interface matching.

The present specification provides an electronic device comprising a memory, a processor and a computer program stored on the memory and executable on the processor, the processor implementing the above-described method of interface matching when executing the program.

The above-mentioned at least one technical scheme that this specification adopted can reach following beneficial effect:

in the interface matching method provided by the specification, the obtained identifiers of the target interfaces are split, all target elements are determined, all target elements are ordered, a tree structure corresponding to all target identifiers is sequentially created according to the ordered results, when the interfaces to be matched are matched in all target interfaces, the obtained identifiers of the interfaces to be matched are split, all the elements to be matched are determined, all the elements to be matched are ordered, all the elements to be matched are sequentially matched with the target elements corresponding to all the nodes in the tree structure according to the ordered results, and the target interfaces matched with the interfaces to be matched in the target interfaces are determined according to the matched results.

According to the method, the tree structure is created, so that the elements to be matched can be more quickly matched with the target elements, the number of target interfaces matched with the interfaces to be matched in the target interfaces can be more quickly and conveniently determined, and the interface matching performance is greatly improved.

Drawings

The accompanying drawings, which are included to provide a further understanding of the specification, illustrate and explain the exemplary embodiments of the present specification and their description, are not intended to limit the specification unduly. In the drawings:

FIG. 1 is a schematic flow chart of interface matching in the present specification;

FIG. 2 is a schematic view of a tree structure provided in the present specification;

FIG. 3 is a schematic diagram of creating a tree structure according to the present disclosure

FIG. 4 is a schematic flow chart of creating a tree structure provided in the present specification;

FIG. 5 is a schematic diagram of a process for matching an element to be matched with a target element according to the present disclosure

FIG. 6 is a schematic diagram of an interface matching device provided in the present specification;

fig. 7 is a schematic view of the electronic device corresponding to fig. 1 provided in the present specification.

Detailed Description

For the purposes of making the objects, technical solutions and advantages of the present specification more apparent, the technical solutions of the present specification will be clearly and completely described below with reference to specific embodiments of the present specification and corresponding drawings. It will be apparent that the described embodiments are only some, but not all, of the embodiments of the present specification. All other embodiments, which can be made by one of ordinary skill in the art without undue burden from the present disclosure, are intended to be within the scope of the present application based on the embodiments herein.

The following describes in detail the technical solutions provided by the embodiments of the present specification with reference to the accompanying drawings.

Fig. 1 is a flow chart of a method for matching interfaces provided in the present specification, specifically including the following steps:

s100: and obtaining the identifiers of a plurality of target interfaces as target identifiers.

The execution subject of the interface matching provided in the present specification may be a server applied to web testing, or may be an electronic device such as a personal computer (Personal Computer, PC) or a mobile phone, and for convenience of description, the method of the interface matching provided in the present specification will be described with only the server as the execution subject.

In the embodiment of the present disclosure, the identifier of the target interface, that is, the target identifier is a uniform resource locator (Uniform Resource Locator, URL), and since the number of interfaces to be tested is generally greater, in the method of the present disclosure, the number of target interfaces is a plurality of target interfaces, a tree structure is created according to the plurality of target interfaces, and the target interface matched with the interface to be matched in the target interfaces is determined through the tree structure.

S101: and splitting each target identifier to determine each target element composing the target identifier.

After the target identifier is acquired, splitting the target identifier by taking the designated character as a boundary, wherein the target identifier is url, and the common format of url is api/v1/v2/data, so that the target identifier is split by taking a 'v' as the designated character, namely taking a 'v' as the boundary, and each target element is determined to be api, v1, v2 and data.

S102: according to the sorting of all the target elements split from all the target identifiers in the target identifiers where the target elements are located, a tree structure corresponding to all the target identifiers is created, wherein each target element corresponds to one node in the tree structure, and the sorting of the target elements corresponding to the father node in the target identifiers is earlier than the sorting of the target elements corresponding to the child nodes in the target identifiers.

As shown in fig. 2, fig. 2 is a tree structure created according to four target identifiers, i/v1/v2/data, i/v2/data and char/v 2, splitting the obtained target identifiers, i/v 2/data/logic, determining each target element, and sorting according to the position of each target element in the identifier, where the sorting of the target elements corresponding to the parent node is earlier than the sorting of the target elements corresponding to the child node in the target identifier, the position of the target element, i, in the target identifier is earlier than the target element v2, the position of the target element v2 in the target identifier is earlier than the target element data, and the position of the target element data in the target identifier is earlier than the target element logic, so that in the tree structure, the node corresponding to the target element api is the parent node of the node corresponding to the target element v2, the node corresponding to the target element data is the parent node of the node corresponding to the target element data, and the node corresponding to the target element data is the parent node of the target element data is the node corresponding to the target element logic, and the tree structure is created as shown in fig. 3.

S103: and for each node of the tree structure, marking the node if the target element corresponding to the node is positioned at the last position in any target identifier.

Continuing to use the above example, when creating the tree structure, marking the node corresponding to the last target element in each obtained target identifier, where the marking may be a character that can be identified, in this specification, marking "#" by taking "#" as an example, according to the above example, it can be known that the last target element in each target identifier is v2, data, and logic, and therefore, marking the node corresponding to the target element v2, data, and logic in the tree structure, as shown in fig. 3.

S104: when the identification of the interface to be matched is obtained, splitting the identification of the interface to be matched, determining each element to be matched forming the identification of the interface to be matched, matching each element to be matched with the tree structure according to the sequence of each element to be matched in the identification of the interface to be matched, determining the node hit by the identification of the interface to be matched, and determining the interface to be matched as one of the target interfaces if the node hit by a leaf node or a marked node.

If the obtained identifier of the interface to be matched is api/v1/v2, splitting the identifier of the interface to be matched, determining that each element to be matched is api, v1 and v2, and sorting, and matching each element to be matched with the tree structure in fig. 3 according to the sorting result, wherein the node hit by the last element v2 to be matched in the identifier to be matched is the node marked in the tree structure, so that it can be determined that the same target interface as the interface to be matched exists in each target interface forming the tree structure in fig. 3; if the obtained identifier of the interface to be matched is api/v2/cluster, splitting the identifier of the interface to be matched, determining that each element to be matched is api, v2 or cluster, and sorting, and matching each element to be matched with the tree structure in fig. 3 according to the sorting result, wherein the last element cluster to be matched in the identifier to be matched does not hit a leaf node or a marked node in the tree structure, so that it can be determined that the interface to be matched is not one of the target interfaces forming the tree structure in fig. 3.

In the method for matching the interfaces, which is provided by the specification, the identifiers of the target interfaces are split to determine each target element, each target element is created into a tree structure, the identifiers of the interfaces to be matched are split to determine each target element to be matched, and the target elements corresponding to each node in the tree structure are matched.

Fig. 4 is a schematic flow chart of creating a tree structure provided in the present specification, specifically including the following steps:

s401: ordering each target element of each target identifier aiming at each target identifier; and each child node of the root node in the tree structure is used as the current node.

For example, a tree structure shown in fig. 2 is created according to four target identifiers of api/v1/v2, api/v1/v2/data, api/v2/data and char/v 2, if the obtained target identifier is api/v2/data/log in, after splitting the target identifier, determining target elements api, v2, data and log in, sorting the target elements, determining the sorting order as api, v2, data and log in, and taking the child nodes of the root node in the tree structure shown in fig. 2, namely, the node 1 and the node 2 as current nodes.

S402: and taking each target element of the target identification as a current element according to the sorting order.

Continuing to use the above example, according to the sorting result, firstly taking the target element api in the target identifier api/v 2/data/logic as the current element.

S403: and judging whether nodes corresponding to the current elements exist in the current nodes, if so, executing a step S404, otherwise, executing a step S405.

S404: and re-determining each child node of the current node corresponding to the current element in the tree structure as the current node, and re-determining the next element of the current element as the current element according to the sorting order, and returning to the step S403.

Through step S403, it may be determined that the target element corresponding to the node 1 in the current node is api, which is the same as the current element api, it is determined that there is a node corresponding to the current element in the current node, step S404 is performed, each child node of the node 1, that is, the node 3 and the node 4 are redetermined as the current node, and the next element v2 of the current element api is redetermined as the current element according to the ordering order, and the step S403 is returned to continue the determination.

S405: creating a child node corresponding to the current element under the parent node of the current node, taking the child node as a newly added node, re-determining each child node of the newly added node as the current node, re-determining the next element of the current element as the current element according to the sorting order, and returning to the step S403.

And sequentially matching other target elements of the target identifier with the tree structure shown in fig. 2 as current elements until the last target element logic in the target identifier is used as the current element, at this time, no current node matched with the current element logic exists in the tree structure shown in fig. 2, determining that no node corresponding to the current element exists in the current node, executing step S405, creating a child node corresponding to the current element logic under the parent node of the current node, namely, the node 7, which is the node 10 in fig. 3, and determining the corresponding node in the tree structure of all the target elements split by the target identifier, as shown in fig. 3.

If the target element is a variable, for example, the obtained target identifier is api/v 2/id=123, when the variable id=123 is the current element, and none of the target elements corresponding to the nodes in the tree structure shown in fig. 2 is a variable, that is, there is no current node matching the current element id=123, then when step S405 is executed, a wild card matching the current element id=123 is generated according to the variable id=123, and a wild card condition corresponding to the wild card is generated, and a child node corresponding to the current element is created under the parent node of the current node, and the description uses "{ }" as the wild card and the wild card condition is id as an example, as shown in fig. 3.

The above example is that a plurality of target identifiers are created into a tree structure, on the basis of the tree structure, the tree structure is extended according to other target identifiers, if no tree structure is created, the obtained target identifiers are split, all target elements are determined and ordered, and nodes corresponding to all target elements are sequentially created under a root node according to the ordering result, wherein the ordering of the target elements corresponding to a parent node in the target identifiers is earlier than the ordering of the target elements corresponding to child nodes in the target identifiers.

Fig. 5 is a schematic flow chart of matching an element to be matched with a target element provided in the present specification, specifically including the following steps:

s501: and sequencing all elements to be matched in the identification of the interface to be matched, and taking all child nodes of the root node in the tree structure as matching nodes.

Taking the tree structure expanded according to the obtained target identifier api/v 2/data/logic in fig. 3 as an example, if the obtained identifier of the interface to be matched is api/v1/v2, determining the elements api, v1 and v2 to be matched, ordering the elements to be matched, determining the matching sequence as api, v1 and v2, and taking the child node of the root node in the tree structure in fig. 3 as a matching node.

S502: according to the sorting order, sequentially aiming at each element to be matched, and taking the element to be matched as a current element;

according to the sorting result, firstly taking the element api to be matched in the mark api/v1/v2 to be matched as the current element.

S503: and judging whether nodes corresponding to the current element exist in the matched nodes, if so, executing the step S504, otherwise, executing the step S505.

S504: and re-determining each child node of the matching node corresponding to the current element in the tree structure as a matching node, and re-determining the next element of the current element as the current element according to the sorting order, and returning to step S503.

Through step S503, it may be determined that the target element corresponding to the node 1 in the matching node is api, which is the same as the current element api, it is determined that there is a node corresponding to the current element in the matching node, step S504 is performed, each sub-node of the node 1, that is, the node 3 and the node 4 are redetermined as matching nodes, and the next element v1 of the current element api is redetermined as a current element according to the ordering order, and step S503 is returned, and the other elements to be matched identified to be used as current elements are continuously determined, and are sequentially matched with the tree structure shown in fig. 3 until the element v2 to be matched in the last position in the identification to be matched is used as the current element, at this time, the current node, that is, the target element corresponding to the node 6 is v2, is determined that there is a node corresponding to the current element v2 in the matching node, and the node is a marked node, and it is determined that there is a target interface identical to the interface to be matched.

S505: and determining that no target interface matched with the interface to be matched exists in the target interfaces.

When matching the element to be matched with the tree structure, firstly performing accurate matching, judging whether the corresponding element in the tree structure is a node of the element to be matched, if so, executing step S504, otherwise, performing fuzzy search, searching for a wildcard corresponding to the wildcard condition matched with the element to be matched, and if so, determining that the element to be matched is matched with the node corresponding to the wildcard.

For example, when the obtained identifier to be matched is api/v 2/id=456 and the variable id=456 is the current element, the obtained identifier is matched with each redetermined matching node, namely, node 7 and node 8, wherein node 8 is a node corresponding to a wild card, the current element id=456 is precisely matched with each matching node first, it is determined that no corresponding element in node 7 is the node of the current element id=456, then a fuzzy search is performed to find the wild card corresponding to the wild card condition matched with the current element id=456, the wild card condition corresponding to the node 8 is id, the current element id=456 meets the wild card condition, and thus it is determined that the current element id=456 is matched with the node corresponding to the wild card.

The method for matching the interfaces provided by the embodiment of the specification can be applied to a test scene, wherein the target interfaces are interfaces to be tested, the interfaces to be matched are interfaces for completing the test, the interfaces to be matched are matched with the target interfaces, the number of the target interfaces matched with the interfaces to be matched in all the target interfaces is determined, and further the test coverage rate and/or the test frequency of each target interface are determined, and the method can also be applied to a statistical scene to count the called or accessed frequency of each target interface and the like.

The above method for matching interfaces provided for one or more embodiments of the present disclosure, based on the same concept, further provides a corresponding device for matching interfaces, as shown in fig. 6.

Fig. 6 is a schematic diagram of an interface matching device provided in the present specification, specifically including:

the acquiring module 601 is configured to acquire identifiers of a plurality of target interfaces as target identifiers;

a determining module 602, configured to split each target identifier, and determine each target element that constitutes the target identifier;

the creating module 603 is configured to create a tree structure corresponding to all target identifiers according to the ranks of the target elements split from all the target identifiers in the respective target identifiers, where each target element corresponds to a node in the tree structure, and the ranks of the target elements corresponding to the parent node in the target identifiers are earlier than the ranks of the target elements corresponding to the child nodes in the target identifiers;

a marking module 604, configured to mark each node of the tree structure if a target element corresponding to the node is located at a last position in any target identifier;

the matching module 605 is configured to split the identifier of the interface to be matched when the identifier of the interface to be matched is obtained, determine each element to be matched that forms the identifier of the interface to be matched, and match each element to be matched with the tree structure according to the ordering of each element to be matched in the identifier of the interface to be matched, so as to determine a node hit by the identifier of the interface to be matched, and determine that the interface to be matched is one of the plurality of target interfaces if a leaf node or a marked node is hit.

Optionally, the creating module 603 is specifically configured to sort, for each target identifier, each target element of the target identifier; each child node of the root node in the tree structure is used as a current node; according to the sorting order, sequentially aiming at each target element of the target mark, and taking the target element as a current element; judging whether nodes corresponding to the current elements exist in the current nodes or not; if yes, each sub node of the current node corresponding to the current element in the tree structure is redetermined as the current node, the next element of the current element is redetermined as the current element according to the ordering sequence, and whether the redetermined node corresponding to the redetermined current element exists in each current node is continuously judged; otherwise, creating a child node corresponding to the current element under the parent node of the current node, using the child node as a newly added node, re-determining each child node of the newly added node as the current node, re-determining the next element of the current element as the current element according to the sorting order, and continuously judging whether the re-determined nodes corresponding to the re-determined current element exist in each current node until the nodes corresponding to all target elements of the target identifier are determined in the tree structure.

Optionally, the creating module 603 is specifically configured to, if the current element is a variable, generate a wild card matched with the variable, and generate a wild card condition corresponding to the wild card according to the variable; creating a child node corresponding to the wild card as the created child node corresponding to the current element;

the matching module 605 is specifically configured to, when an element to be matched is a variable, search a wild card corresponding to a wild card condition matched with the element to be matched, and if a node corresponding to the searched wild card exists in the tree structure, determine that the element to be matched is matched with the node corresponding to the searched wild card.

Optionally, the matching module 605 is specifically configured to sort each element to be matched in the identifier of the interface to be matched, and take each child node of the root node in the tree structure as a matching node; according to the sorting order, sequentially aiming at each element to be matched, and taking the element to be matched as a current element; judging whether nodes corresponding to the current element exist in the matching nodes or not; if not, determining that a target interface matched with the interface to be matched does not exist in the plurality of target interfaces; if so, redefining each sub-node of the matching node corresponding to the current element in the tree structure as a matching node, redefining the next element of the current element as the current element according to the sorting order, and continuously judging whether the redetermined node corresponding to the redetermined current element exists in each redetermined matching node until determining the node corresponding to the last element to be matched in the identification of the interface to be matched, and taking the node corresponding to the last element to be matched in the identification of the interface to be matched as the node hit by the identification of the interface to be matched.

Optionally, the matching module 605 is further configured to determine that no corresponding element in the tree structure is a node of the element to be matched before searching for a wild card corresponding to the wild card condition that matches the element to be matched.

Optionally, the target interface is an interface to be tested; the interface to be matched is an interface for completing the test; the matching module 605 is further configured to determine a test coverage rate and/or a test frequency for each target interface according to the number of target interfaces that are matched with the interface to be matched in the determined target interfaces.

The present specification also provides a computer readable storage medium storing a computer program operable to perform the interface matching method provided in fig. 1 above.

The present specification also provides a schematic structural diagram of the electronic device shown in fig. 7. At the hardware level, the interface matching device includes a processor, an internal bus, a network interface, a memory, and a non-volatile storage, as described in fig. 7, although other hardware required by other services may be included. The processor reads the corresponding computer program from the nonvolatile memory into the memory and then runs the computer program to implement the interface matching method described in fig. 1. Of course, other implementations, such as logic devices or combinations of hardware and software, are not excluded from the present description, that is, the execution subject of the following processing flows is not limited to each logic unit, but may be hardware or logic devices.

In the 90 s of the 20 th century, improvements to one technology could clearly be distinguished as improvements in hardware (e.g., improvements to circuit structures such as diodes, transistors, switches, etc.) or software (improvements to the process flow). However, with the development of technology, many improvements of the current method flows can be regarded as direct improvements of hardware circuit structures. Designers almost always obtain corresponding hardware circuit structures by programming improved method flows into hardware circuits. Therefore, an improvement of a method flow cannot be said to be realized by a hardware entity module. For example, a programmable logic device (Programmable Logic Device, PLD) (e.g., field programmable gate array (Field Programmable Gate Array, FPGA)) is an integrated circuit whose logic function is determined by the programming of the device by a user. A designer programs to "integrate" a digital system onto a PLD without requiring the chip manufacturer to design and fabricate application-specific integrated circuit chips. Moreover, nowadays, instead of manually manufacturing integrated circuit chips, such programming is mostly implemented by using "logic compiler" software, which is similar to the software compiler used in program development and writing, and the original code before the compiling is also written in a specific programming language, which is called hardware description language (Hardware Description Language, HDL), but not just one of the hdds, but a plurality of kinds, such as ABEL (Advanced Boolean Expression Language), AHDL (Altera Hardware Description Language), confluence, CUPL (Cornell University Programming Language), HDCal, JHDL (Java Hardware Description Language), lava, lola, myHDL, PALASM, RHDL (Ruby Hardware Description Language), etc., VHDL (Very-High-Speed Integrated Circuit Hardware Description Language) and Verilog are currently most commonly used. It will also be apparent to those skilled in the art that a hardware circuit implementing the logic method flow can be readily obtained by merely slightly programming the method flow into an integrated circuit using several of the hardware description languages described above.

The controller may be implemented in any suitable manner, for example, the controller may take the form of, for example, a microprocessor or processor and a computer readable medium storing computer readable program code (e.g., software or firmware) executable by the (micro) processor, logic gates, switches, application specific integrated circuits (Application Specific Integrated Circuit, ASIC), programmable logic controllers, and embedded microcontrollers, examples of which include, but are not limited to, the following microcontrollers: ARC 625D, atmel AT91SAM, microchip PIC18F26K20, and Silicone Labs C8051F320, the memory controller may also be implemented as part of the control logic of the memory. Those skilled in the art will also appreciate that, in addition to implementing the controller in a pure computer readable program code, it is well possible to implement the same functionality by logically programming the method steps such that the controller is in the form of logic gates, switches, application specific integrated circuits, programmable logic controllers, embedded microcontrollers, etc. Such a controller may thus be regarded as a kind of hardware component, and means for performing various functions included therein may also be regarded as structures within the hardware component. Or even means for achieving the various functions may be regarded as either software modules implementing the methods or structures within hardware components.

The system, apparatus, module or unit set forth in the above embodiments may be implemented in particular by a computer chip or entity, or by a product having a certain function. One typical implementation is a computer. In particular, the computer may be, for example, a personal computer, a laptop computer, a cellular telephone, a camera phone, a smart phone, a personal digital assistant, a media player, a navigation device, an email device, a game console, a tablet computer, a wearable device, or a combination of any of these devices.

For convenience of description, the above devices are described as being functionally divided into various units, respectively. Of course, the functions of each element may be implemented in one or more software and/or hardware elements when implemented in the present specification.

It will be appreciated by those skilled in the art that embodiments of the present invention may be provided as a method, system, or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.

The present invention is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the invention. It will be understood that each flow and/or block of the flowchart illustrations and/or block diagrams, and combinations of flows and/or blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

In one typical configuration, a computing device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory.

The memory may include volatile memory in a computer-readable medium, random Access Memory (RAM) and/or nonvolatile memory, such as Read Only Memory (ROM) or flash memory (flash RAM). Memory is an example of computer-readable media.

Computer readable media, including both non-transitory and non-transitory, removable and non-removable media, may implement information storage by any method or technology. The information may be computer readable instructions, data structures, modules of a program, or other data. Examples of storage media for a computer include, but are not limited to, phase change memory (PRAM), static Random Access Memory (SRAM), dynamic Random Access Memory (DRAM), other types of Random Access Memory (RAM), read Only Memory (ROM), electrically Erasable Programmable Read Only Memory (EEPROM), flash memory or other memory technology, compact disc read only memory (CD-ROM), digital Versatile Discs (DVD) or other optical storage, magnetic cassettes, magnetic tape magnetic disk storage or other magnetic storage devices, or any other non-transmission medium, which can be used to store information that can be accessed by a computing device. Computer-readable media, as defined herein, does not include transitory computer-readable media (transmission media), such as modulated data signals and carrier waves.

It should also be noted that the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising one … …" does not exclude the presence of other like elements in a process, method, article or apparatus that comprises the element.

It will be appreciated by those skilled in the art that embodiments of the present description may be provided as a method, system, or computer program product. Accordingly, the present specification may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present description can take the form of a computer program product on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) having computer-usable program code embodied therein.

The description may be described in the general context of computer-executable instructions, such as program modules, being executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, etc. that perform particular tasks or implement particular abstract data types. The specification may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both local and remote computer storage media including memory storage devices.

In this specification, each embodiment is described in a progressive manner, and identical and similar parts of each embodiment are all referred to each other, and each embodiment mainly describes differences from other embodiments. In particular, for system embodiments, since they are substantially similar to method embodiments, the description is relatively simple, as relevant to see a section of the description of method embodiments.

The foregoing is merely exemplary of the present disclosure and is not intended to limit the disclosure. Various modifications and alterations to this specification will become apparent to those skilled in the art. Any modifications, equivalent substitutions, improvements, or the like, which are within the spirit and principles of the present description, are intended to be included within the scope of the claims of the present application.

Claims

1. A method of interface matching, the method comprising:

2. The method according to claim 1, according to the sorting of the target elements split from all the target identifiers in the target identifiers where the target elements are located, creating a tree structure corresponding to all the target identifiers, specifically comprising:

3. The method of claim 2, creating a child node corresponding to the current element, comprising:

4. The method of claim 1, wherein the matching each element to be matched with the tree structure specifically comprises:

5. The method of claim 3, further comprising, prior to locating a wild card corresponding to a wild card condition that matches the element to be matched:

6. The method of claim 1, wherein the target interface is an interface to be tested;

the interface to be matched is an interface for completing the test;

the method further comprises the steps of:

7. An apparatus of interface matching, the apparatus comprising:

8. The apparatus of claim 7, the creation module is specifically configured to, for each target identifier, sort target elements of the target identifier; each child node of the root node in the tree structure is used as a current node; according to the sorting order, sequentially aiming at each target element of the target mark, and taking the target element as a current element; judging whether nodes corresponding to the current elements exist in the current nodes or not; if yes, each sub node of the current node corresponding to the current element in the tree structure is redetermined as the current node, the next element of the current element is redetermined as the current element according to the ordering sequence, and whether the redetermined node corresponding to the redetermined current element exists in each current node is continuously judged; otherwise, creating a child node corresponding to the current element under the parent node of the current node, using the child node as a newly added node, re-determining each child node of the newly added node as the current node, re-determining the next element of the current element as the current element according to the sorting order, and continuously judging whether the re-determined nodes corresponding to the re-determined current element exist in each current node until the nodes corresponding to all target elements of the target identifier are determined in the tree structure.

9. The apparatus of claim 8, wherein the creation module is specifically configured to generate a wild card matching the variable if the current element is the variable, and generate a wild card condition corresponding to the wild card according to the variable; creating a child node corresponding to the wild card as the created child node corresponding to the current element;

10. The apparatus of claim 7, wherein the matching module is specifically configured to sort elements to be matched in the identifier of the interface to be matched, and take each child node of the root node in the tree structure as a matching node; according to the sorting order, sequentially aiming at each element to be matched, and taking the element to be matched as a current element; judging whether nodes corresponding to the current element exist in the matching nodes or not; if not, determining that a target interface matched with the interface to be matched does not exist in the plurality of target interfaces; if so, redefining each sub-node of the matching node corresponding to the current element in the tree structure as a matching node, redefining the next element of the current element as the current element according to the sorting order, and continuously judging whether the redetermined node corresponding to the redetermined current element exists in each redetermined matching node until determining the node corresponding to the last element to be matched in the identification of the interface to be matched, and taking the node corresponding to the last element to be matched in the identification of the interface to be matched as the node hit by the identification of the interface to be matched.

11. The apparatus of claim 9, the matching module further configured to determine that no corresponding element in the tree structure is a node of the element to be matched before searching for a wild card corresponding to a wild card condition that matches the element to be matched.

12. The apparatus of claim 7, the target interface being an interface to be tested;

the interface to be matched is an interface for completing the test;

the matching module is further used for determining the test coverage rate and/or the test frequency of each target interface according to the number of the target interfaces matched with the interfaces to be matched in the determined target interfaces.

13. A computer readable storage medium storing a computer program which, when executed by a processor, implements the method of any of the preceding claims 1-6.

14. An electronic device comprising a memory, a processor and a computer program stored on the memory and executable on the processor, the processor implementing the method of any of the preceding claims 1-6 when the program is executed.