CN113051174B - Method for generating simulation protocol message based on XDDL - Google Patents
Method for generating simulation protocol message based on XDDL Download PDFInfo
- Publication number
- CN113051174B CN113051174B CN202110401921.9A CN202110401921A CN113051174B CN 113051174 B CN113051174 B CN 113051174B CN 202110401921 A CN202110401921 A CN 202110401921A CN 113051174 B CN113051174 B CN 113051174B
- Authority
- CN
- China
- Prior art keywords
- message
- xddl
- emulation
- simulation
- python
- 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
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F40/00—Handling natural language data
- G06F40/10—Text processing
- G06F40/12—Use of codes for handling textual entities
- G06F40/14—Tree-structured documents
Abstract
The invention provides a method for generating simulation protocol message based on XDDL (extensible markup language), which is used for embedded software test and comprises the following steps: compiling a simulation message based on the XDDL to generate an XDDL simulation message; a message interface writing the XDDL emulation message based on the XDDL; generating a Python parsing script based on the XDDL simulation message; analyzing the XDDL simulation message through the Python analysis script to generate an analysis simulation message; writing Python script drive based on the Python parsing script; and calling the Python analysis script through the Python script driver, and sending the analysis simulation message. The method aims to solve the problem that in the prior art, a large amount of external simulation needs to be provided when embedded software testing is carried out, but configuration and management of simulation messages are too complex.
Description
Technical Field
The present invention relates to the field of emulation technologies, and in particular, to a method, an electronic device, and a readable storage medium for generating an emulation protocol message based on XDDL.
Background
XDDL, an XML definition description language, is a specific syntactic and semantic rule that defines and describes the coding elements and structures of metadata. Metadata (Metadata) is mainly information describing the attributes of data, i.e. data describing the data, i.e. descriptive information about the data and information resources. In the early development of metadata, custom record languages or database record structures were used as descriptive languages for metadata, but with the increase of metadata formats and interoperability requirements, standardized data definition languages DDL, such as SGML and XML, were used to describe metadata, and XDDL is used more frequently. XDDL as data description language has the following advantages: 1. the grammar is simple; 2. the hierarchical structure is clear; 3. easy to process and edit manually; 4. different levels of conciseness. The test framework may use a separate XDDL file or may read different XDDL files simultaneously. This allows for the differentiation of different types of data definitions, increased readability, and reuse of common data. The use of separate files also enables a reduction in the checking of data parameters when only part of the parameters are changed.
In embedded software testing, a large number of external emulations need to be used. These external emulations require the simulation of message packets of various networks, such as RSSP1, RSSP2 and UDP messages, for testing activities. Different simulators are required according to different message types, so that configuration and management are complicated.
Therefore, it may be considered to provide a method of generating a simulation message based on XDDL, so that configuration and management for the simulation message are simplified.
Disclosure of Invention
The invention aims to provide a method, an electronic device and a readable storage medium for generating a simulation protocol message based on XDDL, which aim to solve the problem that in the prior art, when embedded software test is carried out, a large amount of external simulation needs to be provided, but the configuration and management of the simulation message are too complex.
To achieve the above and other related objects, the present invention provides a method for generating emulation protocol messages based on XDDL, comprising:
compiling a simulation message based on the XDDL to generate an XDDL simulation message;
a message interface writing the XDDL emulation message based on the XDDL;
generating a Python parsing script based on the XDDL simulation message;
analyzing the XDDL simulation message through the Python analysis script to generate an analysis simulation message;
writing Python script drive based on the Python parsing script;
and calling the Python analysis script through the Python script driver, and sending the analysis simulation message.
Preferably, the method further comprises:
and detecting the correctness of the XDDL simulation message format through an XSD file.
Preferably, writing a simulation message based on the XDDL includes packaging and unpacking the simulation message, and refreshing the simulation message through an XDDL file.
Preferably, the XDDL emulation message defines two message types, namely, an "Rx" receive message and a "Tx" transmit message, and each message type at least includes: a message header, a message length, a data content of several bytes, and a CRC check field.
Preferably, generating a Python parsing script based on the XDDL emulation message includes:
analyzing the content of the application data message defined in the XDDL simulation message into a class in Python language, wherein each application data message corresponds to a message class;
analyzing the message field of each application data message into a member variable of a corresponding message class;
defining the base classes of the message classes to be the same, automatically generating derived classes based on the member variables, and providing a unified external interface through the base classes;
the base class provides a unified initialization method to assign the member variables of the message class;
obtaining the value of a member variable of a message class by an SET method change and a GET method;
and automatically packaging the message classes by a Commit method and automatically unpacking the message classes by a Refresh method.
Preferably, the script driver is compiled based on a simulation scenario;
the field value of the XDDL emulation message may be changed and a corresponding emulation scenario is constructed by inputting the corresponding field value.
Preferably, the XDDL emulation message may change the byte section of the field value at least including:
a Message field for indicating the Message name to be set;
a Field for indicating the message content to be set;
a Type field indicating a message Type to be set;
a Value field indicating a message Value that needs to be set.
Preferably, the transmission protocol of the XDDL emulation message and the parsing emulation message includes UDP protocol or TCP protocol.
Based on the same inventive concept, the present invention also provides an electronic device, comprising a processor and a memory, wherein the memory stores a computer program, and the computer program realizes the method of any one of the above items when being executed by the processor.
Based on the same inventive concept, the present invention also provides a readable storage medium, in which a computer program is stored, which, when executed by a processor, implements the method of any one of the above.
Firstly, the invention provides a method for generating simulation messages based on XDDL language, which adopts a uniform language framework to generate XDDL simulation messages for different simulation message types, and generates different Python analysis scripts to analyze the XDDL simulation messages on the basis of different XDDL simulation messages, thereby realizing the uniform processing of the simulation messages, avoiding the need of adopting different simulators for different simulation messages and greatly facilitating the configuration and processing of the simulation messages.
Secondly, the method can construct different simulation scenes by changing the field value of the XDDL simulation message, deploy various message simulators and simulation nodes, simulate the messages required by the simulation test, facilitate fault injection and remote call, does not need code skilled personnel during construction, and is suitable for non-professional personnel.
Drawings
In order to more clearly illustrate the technical solution of the present invention, the drawings used in the description will be briefly introduced, and it is obvious that the drawings in the following description are an embodiment of the present invention, and other drawings can be obtained by those skilled in the art without creative efforts according to the drawings:
fig. 1 is a flowchart illustrating a method for generating an emulation protocol message based on XDDL according to an embodiment of the present invention.
Fig. 2 is a flowchart illustrating a method for generating a Python script in the method for generating an emulation protocol message based on XDDL according to an embodiment of the present invention.
Detailed Description
The method, the electronic device and the readable storage medium for generating an emulation protocol message based on XDDL according to the present invention are described in detail with reference to the accompanying drawings and the detailed description. The advantages and features of the present invention will become more apparent from the following description. It is to be noted that the drawings are in a very simplified form and are all used in a non-precise scale for the purpose of facilitating and distinctly aiding in the description of the embodiments of the present invention. To make the objects, features and advantages of the present invention more comprehensible, reference is made to the accompanying drawings. It should be understood that the structures, ratios, sizes, and the like shown in the drawings and described in the specification are only used for matching with the disclosure of the specification, so as to be understood and read by those skilled in the art, and are not used to limit the implementation conditions of the present invention, so that the present invention has no technical significance, and any structural modification, ratio relationship change or size adjustment should still fall within the scope of the present invention without affecting the efficacy and the achievable purpose of the present invention.
First, technical terms related to the present invention will be described.
Packaging and unpacking in Python: the package group means that a Python interpreter automatically assembles a plurality of data into a container, and the unpacking means that the plurality of data in the container are unpacked. XDDL refers to an XML definition description language, which is a specific syntax and semantic rule that defines and describes the coding elements and structures of metadata. XML refers to the extensible markup language, a subset of standard generalized markup languages, and is a markup language used to mark electronic documents to be structured. An XSD (XML schema definition) file refers to a file of XML structure definitions. The TCP protocol refers to a transmission control protocol that defines the format of data and acknowledged information exchanged for reliable transmission between two computers, and the measures taken by the computers to ensure the correct arrival of the data; the UDP protocol refers to the user datagram protocol, which is a simple datagram-oriented transport layer protocol that provides non-connection-oriented, unreliable transport of data streams. CRC refers to cyclic redundancy check code, which is a commonly used check code with error detection and correction capabilities.
The simulation protocol message generated by the method can be used for testing the embedded software. Referring to fig. 1, a method for generating an emulation protocol message based on XDDL according to an embodiment of the present invention includes the following steps:
s100, compiling a simulation message based on the XDDL to generate an XDDL simulation message;
s200, writing a message interface of the XDDL simulation message based on the XDDL;
s300, generating a Python analysis script based on the XDDL simulation message;
s400, analyzing the XDDL simulation message through the Python analysis script to generate an analysis simulation message;
s500, compiling Python script drive based on the Python analysis script;
s600, calling the Python analysis script through the Python script driver, and sending the analysis simulation message.
The following describes the above steps in detail:
for step S100, writing a simulation message through XDDL, generating an XDDL simulation message, wherein the format of the network message packet is fixed during writing, and in order to prevent the format of the message packet from being incorrect, the written XDDL simulation message may be checked through another XSD file, so as to determine whether the XDDL simulation message format is correct. The XSD file can be used for carrying out the check, the syntax format of the XML file is defined based on the XSD file, strict limitation can be carried out on each parameter variable in the XDDL file, and when the format of the written XDDL file is changed and does not meet the specification, an error can be immediately prompted.
When a simulation message is written, that is, after an XDDL simulation message is obtained, the XDDL simulation message may be bound to another XDDL file, and when the XDDL simulation message is packaged and unpacked, the XDDL simulation message is refreshed by using the another XDDL file.
The following is one example of code for writing the XDDL emulation message:
as in the above code example, the XDDL emulation message defines two message types, namely, an "Rx" receive message and a "Tx" transmit message, and each message type at least includes: a message header, a message length, a number of bytes of data content, and a CRC check field. Of course, it should be understood by those skilled in the art of the present invention that the definition is not limited thereto, and may be increased according to the needs of customers.
For step S200, the message interface writing of the XDDL emulation message is performed to identify the XDDL emulation message, and may be written according to the following codes:
<interfaces>
<interface name＝"yai">
<message ref＝"rx1"/>
<message ref＝"tx1"/>
</interface>
</interfaces>
a name yai of a message interface is defined, which includes two kinds of the XDDL emulation messages "Rx" receive message and "Tx" transmit message defined in step S100.
Referring to fig. 2, for step S300, after the XDDL emulation message is defined, the XDDL emulation message is to be parsed by a Python parsing script, where the Python parsing script parses the XDDL emulation message in a late-binding manner, that is, a Python parsing script is generated by the compiled XDDL emulation message, and then the generated Python parsing script is used to bind and parse the XDDL emulation message. The method specifically comprises the following steps:
s301, analyzing the content of the application data message defined in the XDDL simulation message into a class in a Python language, wherein each application data message corresponds to a message class;
s302, analyzing the message field of each application data message into a member variable of a corresponding message class;
s303, defining the base classes of the message classes to be the same, automatically generating a derived class based on the member variable, and providing a uniform external interface through the base classes;
s304, the base class provides a uniform initialization method to assign the member variables of the message class; obtaining the value of a member variable of a message class by a SET method change and a GET method; and automatically packaging the message classes by a Commit method and automatically unpacking the message classes by a Refresh method.
Step S300 refers to establishing a Python script for parsing the XDDL emulation message based on the generated XDDL emulation message, so that transmission of various emulation messages based on the same framework becomes possible. When the XDDL emulation message file is changed, the corresponding Python script is correspondingly changed, so that when the message structure is changed, only the XDDL configuration of the message needs to be changed, and any analysis script does not need to be changed, thereby greatly improving the working efficiency.
And after the Python analysis script is generated, performing step S400, and analyzing the XDDL simulation message by using the Python analysis script to generate an analysis simulation message.
An example of the code for the Python resolution script is as follows:
class checkword(MessageType):
def__init__(self,instanceName):
self.addField(UInt16Type('msg_id','>',0x5577,None,None,None,[]))
self.addField(UInt16Type('data_len','>',0,None,None,None,[]))
self.addField(UInt8Type('data','>',100,None,None,None,[]))
self.addField(UInt16Type(crc,'>',0x00,None,None,None,[]))
for step S500 and step S600, a Python script driver is written based on the Python parsing script, and when the Python script driver is used for many times, a keyword driver mode may be adopted, that is, some field segments of the XDDL simulation message are changed, and the Python parsing script may generate a corresponding parsing simulation message according to the previous running condition, and send the parsing simulation message to the simulation software.
An example of writing script-driven code is as follows:
<？xml version＝"1.0"encoding＝"UTF-8"？>
<Scenario>
<Time Loophour＝"1"Description＝"">
<Set Message＝"zcciTxSignalDrive"Field＝"SignalDrive[0]"Type＝"uint8"Value＝"0x55"/>
</Time>
</Scenario>
the key-driven is actually a logical extension of the more complex data-driven technology. The data file is changed into the description of the test case, and a series of keywords are used for specifying the task to be executed. In the key-driven technique, it is assumed that the tester has some knowledge of the system under test, so it is not necessary to tell the tester how to perform detailed actions, but only to explain what the test case does, not how to do. Thus used in the script are illustrative methods and descriptive methods. The descriptive method builds knowledge of the software under test in the test automation environment, such knowledge being contained in the supporting scripts. Changing certain fields of the XDDL emulation messages to correspond to different emulation scenarios. The byte section of the field value changeable by the XDDL emulation message includes at least: a Message field for indicating the Message name to be set; a Field for indicating the message content to be set; a Type field indicating a message Type to be set; a Value field indicating a message Value that needs to be set. The transmission protocol of the XDDL simulation message and the analysis simulation message is UDP protocol or TCP protocol.
Based on the same inventive concept, the present invention also provides an electronic device, comprising a processor and a memory, wherein the memory stores a computer program, and the processor implements the method for generating an emulation protocol message based on XDDL as described above when executing the computer program.
The processor may be, in some embodiments, a Central Processing Unit (CPU), a controller, a microcontroller, a microprocessor (e.g., a GPU), or other data Processing chip. The processor is typically used to control the overall operation of the electronic device. In this embodiment, the processor is configured to execute the program code stored in the memory or process data, for example, execute the program code of the method for generating an emulation protocol message based on XDDL.
The memory includes at least one type of readable storage medium including flash memory, hard disks, multimedia cards, card-type memory (e.g., SD or DX memory, etc.), Random Access Memory (RAM), Static Random Access Memory (SRAM), Read Only Memory (ROM), Electrically Erasable Programmable Read Only Memory (EEPROM), Programmable Read Only Memory (PROM), magnetic memory, magnetic disks, optical disks, etc. In some embodiments, the storage may be an internal storage unit of the electronic device, such as a hard disk or a memory of the electronic device. In other embodiments, the memory may also be an external storage device of the electronic device, such as a plug-in hard disk, a Smart Media Card (SMC), a Secure Digital (SD) Card, a Flash memory Card (Flash Card), and the like provided on the electronic device. Of course, the memory may also include both internal and external memory units of the electronic device. In this embodiment, the memory is generally used to store an operating method installed in the electronic device and various application software, such as program codes of a method for generating emulation protocol messages based on XDDL. In addition, the memory may also be used to temporarily store various types of data that have been output or are to be output.
Based on the same inventive concept, the present embodiment also provides a readable storage medium having stored therein a computer program, which when executed by a processor implements the method for generating an emulation protocol message based on XDDL as described above.
The invention has the advantages that for different simulation message types, a unified language framework is adopted to generate the XDDL simulation message, and different Python analysis scripts are generated on the basis of different XDDL simulation messages to analyze the XDDL simulation message, so that the unified processing of the simulation message is realized, different simulators are not required to be adopted for different simulation messages, and the configuration and the processing of the simulation message are greatly facilitated. In addition, different simulation scenes can be constructed by changing the field value of the XDDL simulation message, various message simulators and simulation nodes are deployed, the message required by the simulation test is simulated, fault injection is convenient to perform, remote calling can be performed, code skilled personnel are not needed during construction, and the method is suitable for non-professional personnel.
It should be noted that, in this document, relational terms such as first and second, and the like are used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. Also, the terms "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 an … …" does not exclude the presence of other identical elements in the process, method, article, or apparatus that comprises the element.
While the present invention has been described in detail with reference to the preferred embodiments, it should be understood that the above description should not be taken as limiting the invention. Various modifications and alterations to this invention will become apparent to those skilled in the art upon reading the foregoing description. Accordingly, the scope of the invention should be determined from the following claims.
Claims (9)
1. A method for generating emulation protocol messages based on XDDL, the method comprising:
compiling a simulation message based on XDDL to generate an XDDL simulation message;
a message interface writing the XDDL emulation message based on the XDDL;
generating a Python parsing script based on the XDDL simulation message;
analyzing the XDDL simulation message through the Python analysis script to generate an analysis simulation message;
compiling Python script drive based on the Python parsing script;
calling the Python analysis script through the Python script drive, and sending the analysis simulation message;
generating a Python parsing script based on the XDDL emulation message, comprising:
analyzing the content of the application data message defined in the XDDL simulation message into a class in Python language, wherein each application data message corresponds to a message class;
analyzing the message field of each application data message into a member variable of a corresponding message class;
defining the base classes of the message classes to be the same, automatically generating derived classes based on the member variables, and providing a uniform external interface through the base classes;
the base class provides a unified initialization method to assign the member variables of the message class;
obtaining the value of a member variable of a message class by an SET method change and a GET method;
and automatically packaging the message classes by a Commit method and automatically unpacking the message classes by a Refresh method.
2. The method of generating emulation protocol messages based on XDDL as in claim 1, further comprising:
and detecting the correctness of the XDDL simulation message format through an XSD file.
3. The method of generating emulation protocol messages in accordance with the XDDL of claim 1, wherein composing emulation messages in accordance with the XDDL comprises packaging and unpacking the emulation messages and flushing the emulation messages with an XDDL file.
4. The method of generating an emulation protocol message based on XDDL as claimed in claim 1, wherein the XDDL emulation message defines two message types of "Rx" receive message and "Tx" transmit message, each message type at least comprising: a message header, a message length, a data content of several bytes, and a CRC check field.
5. The method of generating emulation protocol messages based on XDDL of claim 1, wherein the script driver is written based on an emulation scenario;
the field value of the XDDL emulation message may be changed and a corresponding emulation scenario is constructed by inputting the corresponding field value.
6. The method of generating an emulation protocol message on an XDDL basis as claimed in claim 5, wherein the XDDL emulation message can change a byte segment of a field value at least includes:
a Message field for indicating the Message name to be set;
a Field for indicating the message content to be set;
a Type field indicating a message Type to be set;
a Value field indicating a message Value that needs to be set.
7. The method of generating an emulation protocol message on an XDDL basis as claimed in claim 1, wherein the transmission protocols of the XDDL emulation message and the parsing emulation message comprise UDP protocol or TCP protocol.
8. An electronic device, comprising a processor and a memory, the memory having stored thereon a computer program which, when executed by the processor, carries out the method of any one of claims 1 to 7.
9. A readable storage medium, characterized in that a computer program is stored in the readable storage medium, which computer program, when being executed by a processor, carries out the method of any one of claims 1 to 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110401921.9A CN113051174B (en) | 2021-04-14 | 2021-04-14 | Method for generating simulation protocol message based on XDDL |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110401921.9A CN113051174B (en) | 2021-04-14 | 2021-04-14 | Method for generating simulation protocol message based on XDDL |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN113051174A CN113051174A (en) | 2021-06-29 |
| CN113051174B true CN113051174B (en) | 2022-07-26 |
Family
ID=76519663
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110401921.9A Active CN113051174B (en) | 2021-04-14 | 2021-04-14 | Method for generating simulation protocol message based on XDDL |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113051174B (en) |
Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| EP2610754A1 (en) * | 2011-12-28 | 2013-07-03 | Verisign, Inc. | Test automation environment for testing domain name resolution |
| CN103198009A (en) * | 2012-01-04 | 2013-07-10 | 中国移动通信集团公司 | Universal testing method, system and corresponding device |
| CN104965750A (en) * | 2015-06-05 | 2015-10-07 | 浪潮集团有限公司 | Python language based Rapidio switcher logic simulation verification platform and method |
| CN105528290A (en) * | 2015-12-04 | 2016-04-27 | 中国航空综合技术研究所 | Construction method of script-based embedded software simulation and test integrated platform |
| CN107743072A (en) * | 2017-07-04 | 2018-02-27 | 中国电力科学研究院 | Efficiently expansible network simulation scene generating method |
| CN110188385A (en) * | 2019-04-26 | 2019-08-30 | 中国电力科学研究院有限公司 | A kind of method and system for electric system simulation scene modeling |
-
2021
- 2021-04-14 CN CN202110401921.9A patent/CN113051174B/en active Active
Patent Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| EP2610754A1 (en) * | 2011-12-28 | 2013-07-03 | Verisign, Inc. | Test automation environment for testing domain name resolution |
| CN103198009A (en) * | 2012-01-04 | 2013-07-10 | 中国移动通信集团公司 | Universal testing method, system and corresponding device |
| CN104965750A (en) * | 2015-06-05 | 2015-10-07 | 浪潮集团有限公司 | Python language based Rapidio switcher logic simulation verification platform and method |
| CN105528290A (en) * | 2015-12-04 | 2016-04-27 | 中国航空综合技术研究所 | Construction method of script-based embedded software simulation and test integrated platform |
| CN107743072A (en) * | 2017-07-04 | 2018-02-27 | 中国电力科学研究院 | Efficiently expansible network simulation scene generating method |
| CN110188385A (en) * | 2019-04-26 | 2019-08-30 | 中国电力科学研究院有限公司 | A kind of method and system for electric system simulation scene modeling |
Non-Patent Citations (2)
| Title |
|---|
| "Python and XML for Agile Scientific Computing";Michele Vallisneri 等;《Computing in Science & Engineering》;20080104;第10卷(第1期);80-87 * |
| "复杂系统仿真模型集成技术研究";席志磊;《中国优秀博硕士学位论文全文数据库(硕士)-信息科技辑》;20160315;第2016年卷(第3期);I138-7582 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN113051174A (en) | 2021-06-29 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US7143343B2 (en) | Dynamic creation of an application's XML document type definition (DTD) | |
| CN100399323C (en) | Apparatus and method for parsing xml document by using external xml validator | |
| US10417314B2 (en) | Systems and methods of a script generation engine | |
| US20050155016A1 (en) | Flexible code generation | |
| US7962919B2 (en) | Apparatus and method for modifying an initial event queue for extending an XML processor's feature set | |
| EP1156415A2 (en) | Server-side control objects for processing client-side user interface elements | |
| US20040128584A1 (en) | Method and system for determining computer software test coverage | |
| US7130862B2 (en) | Methods, systems and computer program prodcuts for validation of XML instance documents using Java classloaders | |
| CN111428462A (en) | Communication protocol template construction method and terminal equipment | |
| CN110688307B (en) | JavaScript code detection method, device, equipment and storage medium | |
| CN112287009A (en) | Interface calling and interface data warehousing method, device, equipment and storage medium | |
| US8918710B2 (en) | Reducing programming complexity in applications interfacing with parsers for data elements represented according to a markup language | |
| CN111752820B (en) | gRPC interface pressure test method, computer equipment and storage medium | |
| CN113051174B (en) | Method for generating simulation protocol message based on XDDL | |
| US10606569B2 (en) | Declarative configuration elements | |
| US8819645B2 (en) | Application analysis device | |
| US20080313620A1 (en) | System and method for saving and restoring a self-describing data structure in various formats | |
| CN114579466A (en) | Method, device, equipment and medium for constructing test case and code test | |
| CN116233282B (en) | Method and system for analyzing application layer data of signal safety communication protocol | |
| Hercog et al. | Protocol Specification and Design | |
| Neag et al. | Best Practices for Describing Digital Serial Buses and Bus Test Operations Using IEEE 1671 ATML and IEEE 1641 Signal and Test Definition | |
| GB2412765A (en) | Compiled document type definition verifier | |
| Freitas et al. | Specification-based CSV Support in VDM | |
| Kazemi | Integration of component-based frameworks with sensor modeling languages for the sensor web | |
| CN116414689A (en) | Interface parameter verification method and system based on reflection mechanism |
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 |