CN114328276A - Test case generation method and device, and test case display method and device - Google Patents
Test case generation method and device, and test case display method and device Download PDFInfo
- Publication number
- CN114328276A CN114328276A CN202210228832.3A CN202210228832A CN114328276A CN 114328276 A CN114328276 A CN 114328276A CN 202210228832 A CN202210228832 A CN 202210228832A CN 114328276 A CN114328276 A CN 114328276A
- Authority
- CN
- China
- Prior art keywords
- case
- test
- keywords
- field
- name
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
Images
Landscapes
- Debugging And Monitoring (AREA)
Abstract
The invention discloses a test case generation method and a device, and a method and a device for displaying a test case, wherein the test case generation method comprises the following steps: acquiring a local requirement document, extracting keywords, conditions of the keywords and expected results, and respectively putting the keywords, the conditions of the keywords and the expected results into a use case event list; positioning a module function method in a code document, acquiring a function method name and function parameters, and respectively placing the function method name and the function parameters into a code document use case table; extracting the condition of the keyword from the use case event table, and determining the random condition in the interval which is greater than, less than or equal to the condition of the keyword; aiming at the assignment of each group of function parameters, orthogonal sequencing is carried out on the random conditions of the keywords to obtain an orthogonal table object array; and screening the test cases in the orthogonal table object array matched with the expected case result to form a test case set. According to the technical scheme of the invention, the test case can be automatically generated, which is beneficial to improving the test working efficiency and shortening the online period of the product.
Description
Technical Field
The invention relates to the technical field of case testing, in particular to a test case generation method and device, a test case display method and device, a computing device and a readable storage medium.
Background
The test cases are an important ring in software testing, and each product requirement needs to design and compile a large number of test cases, so that the test is executed according to the standard, and the online quality of the product is guaranteed.
The tester needs to compile test cases according to the product requirement documents to execute tests, the compilation cases generally have two directions, the first is compilation case according to the requirement function points, and the second is compilation case according to the business process divergent thinking. Mainly analyzing a product requirement document, listing function points, constructing a flow chart, and utilizing a method for writing a test case according to the function points and the flow chart: and (4) equivalent class division, boundary values, a causal graph and the like, and manually designing and writing test cases.
This needs to manually analyze and compile each module function point, divides and orthogonally combines the input conditions of use cases, consumes a lot of time and energy of testers, and different testers experience and methods are different, and there can be the problem that coverage is incomplete, use cases are not standard, compiling efficiency is low, demand analysis is difficult, so can lead to test use cases to be omitted, testing efficiency is low, the on-line bug influences user experience.
Disclosure of Invention
To this end, the present invention provides a test case generation method and apparatus, a method and apparatus for displaying test cases, a computing device and a readable storage medium in an effort to solve or at least alleviate at least one of the problems identified above.
According to an aspect of the present invention, a test case generation method is provided, including: acquiring a local requirement document, extracting keywords, conditions of the keywords and expected results, and respectively placing the keywords, the conditions of the keywords and the expected results into a case name input condition field, a keyword condition field and a case expected result field of a case event table, wherein the case event table is created in advance by a user and comprises the case name input condition field, the keyword condition field and the case expected result field; positioning a module function method in a code document, acquiring a function method name and function parameters, and respectively placing the function method name and the function parameters into a method module name field and a parameter field in a code document case table, wherein the code document case table is created in advance by a user and comprises the method module name field and the parameter field; extracting conditions of the keywords from the use case event list, and determining random conditions in intervals which are greater than, less than or equal to the conditions of the keywords; assigning values to the function parameters obtained from the code document use case table, and performing orthogonal sequencing on random conditions of the keywords aiming at the assignment of each group of function parameters to obtain an orthogonal table object array, wherein the orthogonal table object array consists of a plurality of test cases; and judging whether each test case in the orthogonal table object array is matched with a case expected result extracted from the case event table, screening the test cases in the orthogonal table object array matched with the case expected result, and forming a test case set.
According to another embodiment of the present invention, a test case generation method is provided, including: searching the repeated characteristics of partial modules in a local requirement document, and filling the repeated characteristics into a use case name field of a common use case library, wherein the common use case library is created in advance by a user and comprises the use case name field, an input condition field and a use case expected result field; filling the execution step of the repeated characteristic into an input condition field of the common use case base; filling expected results of the step of executing the repetitive nature into a use case expected result field of the common use case base.
According to another embodiment of the present invention, a method for displaying test cases generated according to the above method is provided, including: receiving a user instruction to create a parent node on a graphical user interface; and responding to the click of the father node, searching the version management case library, and extracting the standard case data corresponding to the father node to the graphical user interface by using a thinking guide graph.
According to another embodiment of the present invention, a method for displaying test cases generated according to the above method is provided, including: receiving a user instruction to create a parent node on a graphical user interface; and responding to the click of the parent node, searching the public use case library, and extracting use case data corresponding to the parent node to the graphical user interface by using a thinking graph.
According to another embodiment of the present invention, there is provided a test case generation apparatus including: the system comprises a first acquisition module, a second acquisition module and a third acquisition module, wherein the first acquisition module is used for acquiring a local requirement document, extracting keywords, conditions of the keywords and expected results, and respectively placing the keywords, the conditions of the keywords and the expected results into a case name input condition field, a keyword condition field and a case expected result field of a case event table, and the case event table is created in advance by a user and comprises the case name input condition field, the keyword condition field and the case expected result field; the second acquisition module is used for positioning a module function method in the code document, acquiring a function method name and function parameters, and respectively placing the function method name and the function parameters into a method module name field and a parameter field in a code document case table, wherein the code document case table is created by a user in advance and comprises a method module name field and a parameter field; the extraction module is used for extracting the conditions of the keywords from the use case event table and determining the random conditions in the interval which is greater than, less than or equal to the conditions of the keywords; the orthogonal sorting module is used for assigning values to the function parameters obtained from the code document use case table, and carrying out orthogonal sorting on the random condition of the key words aiming at the assignment of each group of function parameters to obtain an orthogonal table object array, wherein the orthogonal table object array consists of a plurality of test cases; and the screening module is used for judging whether each test case in the orthogonal table object array is matched with the case expected result extracted from the case event table or not, screening the test cases in the orthogonal table object array matched with the case expected result, and forming a test case set.
According to another embodiment of the present invention, there is provided an apparatus for displaying test cases generated according to the above method, including: the creation module is used for receiving a user instruction so as to create a father node on the graphical user interface; and the extraction module is used for responding to clicking of the father node, searching the version management case library, and extracting the standard case data corresponding to the father node to the graphic user plane by using a thinking guide graph.
According to another embodiment of the present invention, there is provided a computing device including: at least one processor and a memory storing program instructions; when the program instructions are read and executed by the processor, the computing device is caused to execute the test case generation method or the test case display method.
According to another embodiment of the present invention, there is provided a readable storage medium storing program instructions, which when read and executed by a computing device, cause the computing device to execute the test case generation method or the test case display method.
According to the technical scheme of the invention, the test case can be automatically generated, which is beneficial to improving the test working efficiency and shortening the online period of the product.
Drawings
To the accomplishment of the foregoing and related ends, certain illustrative aspects are described herein in connection with the following description and the annexed drawings, which are indicative of various ways in which the principles disclosed herein may be practiced, and all aspects and equivalents thereof are intended to be within the scope of the claimed subject matter. The above and other objects, features and advantages of the present disclosure will become more apparent from the following detailed description read in conjunction with the accompanying drawings. Throughout this disclosure, like reference numerals generally refer to like parts or elements.
FIG. 1 shows a schematic diagram of a computing device 100, according to one embodiment of the invention;
FIG. 2 illustrates a flow diagram of a test case generation method 200 according to one embodiment of the invention;
FIG. 3 illustrates what function parameters may include in the example of a username-password login;
FIG. 4 illustrates an example of a set of use cases generated by a method according to an embodiment of the present invention;
FIG. 5 illustrates one example of populated data within a common use case library;
FIG. 6 illustrates a method 600 of displaying the test cases generated above;
FIG. 7 illustrates a use case extracted by the method 600;
FIG. 8 provides an overall architecture diagram according to an embodiment of the present invention;
FIG. 9 is a schematic block diagram of a test case generation apparatus 900 according to an embodiment of the present invention;
FIG. 10 illustrates an apparatus 1000 that displays the test cases generated above.
Detailed Description
Exemplary embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. While exemplary embodiments of the present disclosure are shown in the drawings, it should be understood that the present disclosure may be embodied in various forms and should not be limited to the embodiments set forth herein. Rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the scope of the disclosure to those skilled in the art.
The invention provides a test case generation method, which can save time of testers, diversify test modes and improve product demand coverage rate test, thereby improving software test efficiency while ensuring software test quality.
The test case generation method for the invention is executed in the computing equipment. The computing device may be any device with storage and computing capabilities, and may be implemented as, for example, a server, a workstation, or the like, or may be implemented as a personal computer such as a desktop computer or a notebook computer, or may be implemented as a terminal device such as a mobile phone, a tablet computer, a smart wearable device, or an internet of things device, but is not limited thereto.
FIG. 1 shows a schematic diagram of a computing device 100, according to one embodiment of the invention. It should be noted that the computing device 100 shown in fig. 1 is only an example, and in practice, the computing device for implementing the test case generation method of the present invention may be any type of device, and the hardware configuration thereof may be the same as that of the computing device 100 shown in fig. 1 or different from that of the computing device 100 shown in fig. 1. In practice, the computing device for implementing the test case generation method of the present invention may add or delete hardware components of the computing device 100 shown in fig. 1, and the present invention does not limit the specific hardware configuration of the computing device.
As shown in FIG. 1, in a basic configuration 102, a computing device 100 typically includes a system memory 106 and one or more processors 104. A memory bus 108 may be used for communication between the processor 104 and the system memory 106.
Depending on the desired configuration, the processor 104 may be any type of processing, including but not limited to: a microprocessor (μ P), a microcontroller (μ C), a digital information processor (DSP), or any combination thereof. The processor 104 may include one or more levels of cache, such as a level one cache 110 and a level two cache 112, a processor core 114, and registers 116. The example processor core 114 may include an Arithmetic Logic Unit (ALU), a Floating Point Unit (FPU), a digital signal processing core (DSP core), or any combination thereof. The example memory controller 118 may be used with the processor 104, or in some implementations the memory controller 118 may be an internal part of the processor 104.
Depending on the desired configuration, system memory 106 may be any type of memory, including but not limited to: volatile memory (such as RAM), non-volatile memory (such as ROM, flash memory, etc.), or any combination thereof. The physical memory in the computing device is usually referred to as a volatile memory RAM, and data in the disk needs to be loaded into the physical memory to be read by the processor 104. System memory 106 may include an operating system 120, one or more applications 122, and program data 124. In some implementations, the application 122 can be arranged to execute instructions on an operating system with program data 124 by one or more processors 104. Operating system 120 may be, for example, Linux, Windows, etc., which includes program instructions for handling basic system services and performing hardware dependent tasks. The application 122 includes program instructions for implementing various user-desired functions, and the application 122 may be, for example, but not limited to, a browser, instant messenger, a software development tool (e.g., an integrated development environment IDE, a compiler, etc.), and the like. When the application 122 is installed into the computing device 100, a driver module may be added to the operating system 120.
When the computing device 100 is started, the processor 104 reads program instructions of the operating system 120 from the memory 106 and executes them. The application 122 runs on top of the operating system 120, utilizing the operating system 120 and interfaces provided by the underlying hardware to implement various user-desired functions. When the user starts the application 122, the application 122 is loaded into the memory 106, and the processor 104 reads the program instructions of the application 122 from the memory 106 and executes the program instructions.
The computing device 100 also includes a storage device 132, the storage device 132 including removable storage 136 and non-removable storage 138, the removable storage 136 and the non-removable storage 138 each connected to the storage interface bus 134.
Computing device 100 may also include an interface bus 140 that facilitates communication from various interface devices (e.g., output devices 142, peripheral interfaces 144, and communication devices 146) to the basic configuration 102 via the bus/interface controller 130. The example output device 142 includes a graphics processing unit 148 and an audio processing unit 150. They may be configured to facilitate communication with various external devices, such as a display 153 or speakers, via one or more a/V ports 152. Example peripheral interfaces 144 may include a serial interface controller 154 and a parallel interface controller 156, which may be configured to facilitate communication with external devices such as input devices (e.g., keyboard, mouse, pen, voice input device, touch input device) or other peripherals (e.g., printer, scanner, etc.) via one or more I/O ports 158. An example communication device 146 may include a network controller 160, which may be arranged to facilitate communications with one or more other computing devices 162 over a network communication link via one or more communication ports 164.
A network communication link may be one example of a communication medium. Communication media may typically be embodied by computer readable instructions, data structures, program modules, and may include any information delivery media, such as carrier waves or other transport mechanisms, in a modulated data signal. A "modulated data signal" may be a signal that has one or more of its data set or its changes made in such a manner as to encode information in the signal. By way of non-limiting example, communication media may include wired media such as a wired network or private-wired network, and various wireless media such as acoustic, Radio Frequency (RF), microwave, Infrared (IR), or other wireless media. The term computer readable media as used herein may include both storage media and communication media.
In a computing device 100 according to the present invention, the application 122 includes instructions for performing the test case generation method 200 of the present invention, which may instruct the processor 104 to perform the test case generation method 200 of the present invention. Those skilled in the art will appreciate that the applications 122 may include other applications 126 for implementing other functionality in addition to instructions for performing the test case generation method 200.
FIG. 2 shows a flow diagram of a test case generation method 200 according to one embodiment of the invention. The method 200 is described in detail below with reference to fig. 2. As shown in fig. 2, the method 200 includes:
step S210, obtaining a local requirement document, extracting keywords, conditions of the keywords and expected results, and respectively placing the keywords, the conditions of the keywords and the expected results into a case name input condition field, a keyword condition field and a case expected result field of a case event table.
The local requirement document expresses the requirement of the product through contents such as characters, graphics and the like, and can present the requirement to a user after being transmitted to development and designers and online. After the local relevant requirement document is obtained, the document can be analyzed line by line, a semantic model is created (words are segmented, word attributes such as nouns or verbs are labeled), and the semantic is analyzed and combined (the result of combining the keywords with each other) to extract the keywords, the conditions of the keywords and the expected result.
The method 200 is described herein with respect to a username-password login case. In this case, the keywords obtained from the local requirement document are the user name and the password, the condition of the keywords may be the length and the language category of the user name and the password, and the expected result may be whether the user name and the password match can be successfully logged in.
The use case event table is created by a user in advance and includes a use case name input condition field, a keyword condition field, and a use case expected result field. Specifically, a use case event table may be added to a data storage repository (database) in the computing system, a model field is set in the use case event table, and a module name of a requirement document is recorded through the field; setting a keyword (keywords) field, and recording a case name input condition through the keyword field; setting a keyword condition (keypoints) field, and recording a condition required by the keyword corresponding to the keyword through the field; and setting a use case expected result (kraresult) field, and recording the use case expected result corresponding to the keyword use case name through the field.
S220, positioning a module function method in the code document, acquiring a function method name and function parameters, and respectively placing the function method name and the function parameters into a method module name field and a parameter field in a code document use case table.
This step can be implemented by constructing a baseCode method. The code document is a document for specifying product functions in detail based on a local requirement document, and codes for realizing the functions are recorded in the code document and comprise module function methods, and the module function methods refer to self-defined method names in the program codes for realizing the function requirements. The function method name is marked and the function of the function is realized, and may be a program, such as a method for obtaining the total amount of money that the user wants, the function method name may be getivebill total, and in the example of the user name and the password herein, the function method name may be "/api/usernapi/standardlog"; the function parameters are the operating parameters of the function method.
Step S220 is to acquire parameters from the code document, and to combine the data of step S210 to realize bidirectional assurance. The requirement document only provides a textual description, such as the keyword being a user name, if Chinese, and the length being within 10 characters. The code document records a detailed code based on the requirement document, by which parameters defined when writing the code can be acquired. The modules and parameters in the code document are extracted, the method and the parameters are obtained, missing parts of the required document can be made up, double guarantee of the document and the codes is achieved, and keywords and conditions of each module are completely used as parameters for generating a use case.
In the examples herein, in addition to the keyword, i.e. username and password information, there is a need to know many other information, such as the platform used, etc. In the example of a username-password login, the function parameters may include the contents shown in FIG. 3. In fig. 3, parameter appid refers to a request source, fposition refers to a secondary service line name identifier, ischeckmodermattersremote refers to whether to log in a different place, ispapp refers to whether to app or not, loginceode refers to a user name, platform refers to a platform, which may be a personal computer or the like, sPosition refers to a landing page identifier, showmob refers to a mobile phone number after parameter control whether to desensitize back, and validcode refers to a verification code.
The code document use case table employed in step S220 is created in advance by the user. Specifically, a code document use case table may be added in the database, and the code document use case table may be provided with a method field, and record a corresponding method module name in the code document through the method field, and then set a param field (each param field may include 1 to 20 fields) for recording function parameters corresponding to the scanned code method. The number of fields included in the Param field may also be other values, and the invention is not limited herein.
S230, extracting the condition of the keyword from the use case event table, and determining the random condition in the interval which is greater than, less than or equal to the condition of the keyword.
Specifically, a baseModel method may be defined first, and a model algorithm for generating a use case may be generated by using characteristics of a boundary value, an equivalence class, an orthogonal table, a causal graph, and the like in the use case writing method. Inputting concrete data content into the model algorithm, and obtaining a corresponding test case. Thus, a use case generation model is formed by using use case writing methods such as an equivalence class, a boundary value, an orthogonal table, a causal graph, a scene method and the like, and a use case with a relatively complete coverage and no redundancy is generated by using the model algorithm.
In step S230, the condition of the keyword extracted from the use case event table may be input to the model algorithm. This can be achieved by constructing a baseResult method. For example, in the case of a user name and a password, the extracted keywords are provided that the user name length is not greater than 10 and is chinese/english/numeric, and the password length is not greater than 10 and is english/numeric/special characters. The condition is a boundary value property written in a use case.
Then, a random condition in a section larger than, smaller than, or equal to the condition is determined based on the boundary value. Specifically, in the above example, the sections of less than 10 bits, equal to 10 bits, and greater than 10 bits are determined. The number of bits such as 7 and 8 may be randomly set for intervals smaller than 10 bits. Since both 7 and 8 are less than 10, only one need be tested, so that, for example, 8 cases can be omitted in the following steps — where the equivalent class of case writing is used. For each interval (interval greater than 10 bits, 10-bit interval, and interval less than 10 bits), the user name (i.e. random condition within the interval) can be randomly set for the following test, such as user name (logincide) and password (userpwwd) can be respectively set as:
logincode=192200009998&userpwd=qqqq
loginceode = flower drop & userpwd =111qqq waiting for flower to bloom
logincide = flower and flower fall & userpwd = # … … # 111qqq111 qqqq for flower and flower fall waiting for blooming
logincide = rheuh flower colony 8& userpwd =3232323
logincode=autohome340&userpwd=autohome7973757
logincode=*&*&¥341&userpwd=111qqq
logincode=*&*&¥342&userpwd=EWRFEREBfwkeuh434
In addition to random settings, the desired username and password may also be retrieved from an existing database. The invention is not limited thereto.
S240, assigning values to the function parameters obtained from the code document use case table, and performing orthogonal sequencing on the random conditions of the keywords aiming at the assignment of each group of function parameters to obtain an orthogonal table object array, wherein the orthogonal table object array consists of a plurality of test cases.
FIG. 4 illustrates an example of a generated set of use cases. The assignment of the parameters in the code document use case table shown in fig. 4 can be from a public database, and if no relevant data exists in the public database, fields and character strings can be automatically generated by a custom method to assign the parameters. The combination of parameter assignments may be custom, for example, an algorithm may be written in advance, and a combination of high coverage may be selected according to the algorithm.
Based on the parameter assignment in the example table of the code document (such as the first set of assignments of fig. 4: _ appid = pc & fPosition =10004& ischecksodermemote =1& ispapp =1& platform =0& sPosition =1000405& showmob =0& validcode = uoib), for each set of parameter assignments, various ordering combinations are made for the random conditions of the keywords (user names), such as the combination of the user name "19220009999" with the passwords "111 qqq" and "3232323", the combination of the user name "flower waiting for blooming" with the passwords "111 qqq" and "3232323", and so on, so as to obtain an orthogonal table object array. Each combination in the array of orthogonal table objects is a test case.
The above combinations may be exhaustive or partial combinations. The exhaustive combination can also be performed when the parameters are small. When the parameters are more, the combination with high coverage rate can be obtained according to the orthogonal table written in advance. The orthogonal tables are compiled in advance and describe how to combine to get a high coverage use case.
The use case set shown in fig. 4 is only a part of the last generated use case set, and does not contain all combinations of usernames and passwords. The left "/api/usernapi/standardlog 01" and the like are names of each use case, are automatically generated during orthogonal sorting, and are named according to the order of the generation of the use cases, as shown in fig. 4: "/api/usernapi/standardLogin 01", "/api/usernapi/standardLogin 02", and the like.
As shown in fig. 4, the use case set includes a case where the user name or the password is null, because the case where the user name or the password is null also needs to be tested to check whether the interface has an error.
By a model algorithm, namely a baseModel method, the model is calculated in advance to automatically generate the orthogonal sequencing combination, so that the defects of large workload, long testing time and the like caused by manual filling one by one can be avoided.
S250, judging whether each test case in the object array of the orthogonal table is matched with the case expected result extracted from the case event table or not, screening the test cases in the object array of the orthogonal table, which are matched with the case expected result, and forming a test case set.
The execution purpose of step S250 is to determine whether the orthogonal table object array obtained in step S240 matches the expected result of the use case in the use case event table, that is, to perform causal combination, so as to obtain a test case set matching the expected result.
Before the matching judgment, the orthogonal table object array obtained in step S240 may be subjected to filtering and clipping. This is because the orthogonal table object array may contain the case where the user name and password are null, such a use case may be cut out from the orthogonal table object array to obtain a test set, and then the test set is causally combined with the expected result of the use case from the use case event table.
The obtained test case set can also be subjected to repeated elimination operation, specifically to repeated elimination with data in a common case library. Specifically, the data in the test case set and the common use case library may be subjected to keyword sequence sorting and combination according to keywords to exclude repeated use cases in the common use case library, and the generated test cases may replace the repeated use cases in the common library.
The common use case base is described below. The common use case library refers to a use case library which can be used by all testers and comprises a use case name field, an input condition field and a use case expected result field. In practice, a common use case base table can be added in the database, a module model field can be set in the common use case base table, and the module name of the common use case base is recorded through the field; setting a keyword fields, and recording the use case names of the common use case libraries through the keyword fields; setting a keypoints field, and recording the input condition of the common use case name through the field; and setting a kraresult field, and recording the expected result of the use case corresponding to the name of the use case in the common use case library through the kraresult field. FIG. 5 illustrates one example of populated data within a common use case library.
The method 200 may also include the step of populating the common use case base. Specifically, after the use case event table is filled in step S210, the baseStruct method may be executed on the use case event table by, for example, constructing a baseStruct method, searching for the repetition characteristics of a part of modules in the local requirement document, and filling the repetition characteristics into the use case name field of the common use case base; filling the execution step of the repeated characteristic into an input condition field of the common use case base; filling expected results of the step of executing the repetitive nature into a use case expected result field of the common use case base. Thus, version management is carried out after the cases are automatically generated, and the public modules can be extracted and put into the public case library.
The repeated characteristics are searched and filled into the common use case base, so that the common characteristics are stored in the common base and can be called by a tester at a later date. And the parts which do not belong to the commonalities can be stored in the use case event table mentioned in the step S210 by searching the keywords according to the requirement.
The partial modules described above may be pages. A document, for example, is composed of multiple pages, each page contains a list, and the list contains some repetitive features such as pull-down, load, refresh, and the like. In addition, duplicate features such as search boxes, text boxes, uploading pictures, viewing pictures, etc. may be included. These repetition properties may fill in the use case name field described above. In the example shown in fig. 5, "add picture" is a repeating property.
According to another embodiment of the present invention, there is also provided a test case generation method, including the step of filling the common case base, specifically: searching the repeated characteristics of partial modules in a local requirement document, and filling the repeated characteristics into a use case name field of a common use case library, wherein the common use case library is created in advance by a user and comprises the use case name field, an input condition field and a use case expected result field; filling the execution step of the repeated characteristic into an input condition field of the common use case base; filling expected results of the step of executing the repetitive nature into a use case expected result field of the common use case base.
In the event that it is not necessary/desirable to generate test cases according to the steps of method 200, the tests may be performed directly using the data populated in the common case base.
The method 200 is described further below. The test case generated in step S250 is a data set, and includes a user name, a password, and an expected result. The method 200 may further include a step of converting the test case generated in step S250 into standard case data, where the standard case data uses a case header, a case step, and an expected result as a template, where a case name of the test case is converted into the case header in the standard case data, each combination in the orthogonal table object array of the test case is converted into the case step, and a case expected result of the test case is converted into the expected result in the standard case data.
The specific implementation manner of the conversion step may be: a baseLib method is defined, and the method can generate a case template, wherein the case template comprises a case title, a case step and an expected result and is used for storing the generated test case. Then, after the test case is generated in step S250, the baseLib method is called as input data, so that standard case data using the case header, the case step, and the expected result as templates can be generated.
The converted standard case data can be stored, specifically, stored in the version management case library. In practice, a version management example library can be additionally arranged in the database, and a ver field can be arranged in the version management example library and used for recording the version number of the test case automatically generated by each version; a title field for recording the title name of the generated test case; a summary field for recording the steps of the test case; and a result field for recording the expected result of the test case.
The method 200 may further include: after the test case data is generated and converted into the standard test case data according to step S250, it can also be exported to the created GUI page by means of a mind map.
The above is displayed directly on the GUI page after the standard test case data is generated. In addition, after the test case data generated in step S250 is converted into standard test case data and stored in the version management case library, the case data may be retrieved from the version management case library and displayed on a page. The generated cases are stored in a version management case library, a plurality of module cases are supported to be extracted according to needs, and regression testing in the version iteration process is facilitated.
Therefore, according to the embodiment of the present invention, there is also provided a method 600 for displaying the test case generated above. As shown in fig. 6, the method 600 includes: s610, receiving a user instruction to create a father node on a graphical user interface; s620, responding to the click of the father node, searching the version management case base, and extracting the standard case data corresponding to the father node to the graphic user plane by using a thinking guide graph.
Extracted by the method 600 is shown, for example, in fig. 7. Wherein the "login registration" is the created parent node. In practice, after the parent node 'login' is created, right clicking can occur, for example, 'extraction' of two characters and 'extraction' clicking can occur, the method can automatically search the version management use case library, and use cases needing to be used are extracted and displayed behind the parent node. After all test cases are exported, the unwanted cases can be deleted on the interface.
The method 600 may further include: and importing the test cases corresponding to the keywords on the graphical user interface into the common case library. Specifically, when a certain use case keyword of a parent node of the mind map is right-clicked, for example, "login registration" or a user name node shown in fig. 7 is clicked, an "import" two word appears, and "import" is clicked, all child nodes behind the use case keyword can be imported into the public use case library.
This is because: after a new use case set is generated, the use case set may be more comprehensive than the use cases in the public library, which also depends on whether the requirement document is written in detail, and if the requirement document is written in detail, the test use case set may be more comprehensive than the use cases in the public library. And the user with the public control attribute is imported into the public use case library, so that the use case multiplexing rate can be circularly improved. In addition, in importing, a case that is desired to be imported or not imported can be selected.
The method 600 may further include: and searching the public use case library, searching for use cases corresponding to the keywords on the mind map, and displaying the use cases on the graphical user interface by the mind map. Specifically, on the mind map shown in fig. 7, a right click on a case keyword such as "login registration" of a parent node may cause "matching" of two characters, and "matching" may be clicked, so that a data table in the common case library may be searched, and a case corresponding to the keyword is displayed behind the keyword on the graphical user interface by the mind map, thereby implementing automatic matching of case library data.
Performing this operation may yield the following benefits: the use cases generated by the method 200 are part of the expected use cases, and if it is desired to search for use cases in a common library to supplement, matching can be performed by the matching method. For example, if a text box is desired to be tested, whether a use case of the text box exists can be searched in the common use case library, and the use case is matched with a displayed test case on the page.
Therefore, a model algorithm can be developed according to a use case compiling method to generate a use case, the use case is matched with data of a common use case base, and the use case and the data are combined to automatically generate a standardized use case.
There is also a case where: without generating any use case according to the method 200, a parent node is directly created on the page, and the use cases in the common use case library are matched and displayed. Therefore, according to another embodiment of the present invention, there is also provided a method for displaying test cases in a common use case library, including: receiving a user instruction to create a parent node on a graphical user interface; and responding to the click of the parent node, searching the public use case library, and extracting use case data corresponding to the parent node to the graph user plane by using a thinking graph.
Fig. 8 provides an overall architecture diagram of an embodiment of the present invention. As shown in fig. 8, according to the technical solution of the present embodiment, required data is obtained from a requirement document and a code document, a test case set is generated at a server and stored in a relevant database, and then displayed in a User Interface (UI) platform in the form of a mind map, and functions of importing, extracting, and matching can be provided during displaying. Where the API is an application program interface.
According to the embodiment of the invention, the method for automatically generating the test case is provided, so that the time for a tester to manually compile the case is saved, and the coverage of the test case, the test accuracy and the test efficiency are improved. The method executes the steps S230-S250 based on the extraction of the data in the use case event table and the code document use case table, can quickly process a huge and complex requirement, and can be combined with the abnormal and common control characteristic templates of the common use case library to automatically generate a use case document with a full coverage. Before each execution, the corresponding module methods implemented in the requirement document and the code document are firstly analyzed, and the accuracy of the executed data is confirmed. The keywords and keyword conditions obtained from the requirement document are stored in the use case event table, the methods and parameters obtained from the code document are stored in the code document use case table, and the keywords obtained from the use case event table and the code document use case table are arranged and combined to serve as the input conditions of the step S240, so that a use case set is generated. Therefore, the automatic generation of the use case can be completed, the use case extraction is supported to carry out a plurality of branch use case combinations, and the version iterative regression test is facilitated. And a platform page can be established, the page supports reading of files in the common use case library, the files are converted into a thinking guide graph format to be displayed on the platform page, one-key matching, leading-in to the common library and extraction of use cases are supported, and compiling, management and execution of the use cases by testers are facilitated.
Through the processing of the steps S230-S250, a model algorithm can be formed by combining a plurality of methods for compiling the test cases, the event of manually compiling the cases is saved, the condition that part of functional test points are missed due to the fact that testers consider the cases or the case compiling method is incomplete is avoided, the coverage of various orthogonal combinations and the maximum probability of boundary analysis of parameters and key points in a requirement document and a code document is realized by using the fewest and most prudent test cases, the redundancy of the test cases is avoided, and the test accuracy and the coverage rate are improved.
In addition, the common use case library can be extracted, the use case sets generated by the requirement document and the common use case library are sequenced and combined into a standardized use case and stored, extraction and management are facilitated, and labor cost is reduced.
The problems of low use case reuse rate and the like caused by more testers, frequent version iteration, inconvenient use case management, multiple regression testing of functions and the like are solved through thinking guide diagram display.
In conclusion, the test case generated according to the embodiment of the invention has good user experience, comprehensive, rapid, accurate and reliable data, and has portability and expandability in the automatic generation of the test case.
According to the embodiment of the invention, the invention also provides a test case generation device. Fig. 9 is a schematic block diagram of the test case generation apparatus 900. As shown in fig. 9, the apparatus includes:
the first obtaining module 910 obtains the local requirement document, extracts the keyword, the condition of the keyword, and the expected result, and puts the keyword, the condition of the keyword, and the expected result into a use case name input condition field, a keyword condition field, and a use case expected result field of the use case event table, respectively.
The device is described herein with the case of a username-password login as an example. In this case, the keywords obtained from the local requirement document are the user name and the password, the condition of the keywords may be the length and the language category of the user name and the password, and the expected result may be whether the user name and the password match can be successfully logged in.
The second obtaining module 920 locates a module function method in the code document, obtains a function method name and a function parameter, and places the function method name and the function parameter in a method module name field and a parameter field in a code document use case table, respectively.
The extracting module 930 extracts the condition of the keyword from the use case event table, and determines a random condition in an interval greater than, less than, or equal to the condition of the keyword.
And an orthogonal sorting module 940, configured to assign values to the function parameters obtained from the code document use case table, and perform orthogonal sorting on the random condition of the keyword according to the assignment of each group of function parameters, so as to obtain an orthogonal table object array, where the orthogonal table object array is composed of multiple test cases.
The screening module 950 determines whether each test case in the orthogonal table object array matches the case expected result extracted from the case event table, screens out the test cases in the orthogonal table object array matching the case expected result, and forms a test case set.
The apparatus 900 may further include a clipping module, configured to perform filtering clipping on the obtained orthogonal table object array before performing the matching determination. This is because the orthogonal table object array may contain the case where the user name and password are null, such a use case may be cut out from the orthogonal table object array to obtain a test set, and then the test set is causally combined with the expected result of the use case from the use case event table.
The apparatus 900 may further include a deduplication module, configured to perform deduplication operations on the obtained test case set, specifically, perform deduplication with data in the common case library. Specifically, the data in the test case set and the common use case library may be subjected to keyword sequence sorting and combination according to keywords (function parameters in the test case set, use case name fields in the common use case library) to exclude repeated use cases in the common use case library, and replace the repeated use cases in the common use case library with the generated test cases.
The apparatus 900 may also include a common use case repository population module: the method is used for executing the baseStruct method on the use case event table, searching the repeated characteristics of partial modules in the local requirement document, and filling the repeated characteristics into the use case name field of the common use case library; filling the execution step of the repeated characteristic into an input condition field of the common use case base; filling expected results of the step of executing the repetitive nature into a use case expected result field of the common use case base. Thus, version management is carried out after the cases are automatically generated, and the public modules can be extracted and put into the public case library.
The apparatus 900 may further include a conversion module configured to convert the test case into standard case data, where the standard case data uses a case header, a case step, and an expected result as a template, where a case name of the test case is converted into the case header in the standard case data, each combination in the orthogonal table object array of the test case is converted into the case step, and the expected result of the test case is converted into the expected result in the standard case data.
The apparatus 900 may further comprise an export module for exporting the test case data to the created GUI page by means of a mind map after generating the test case data and converting the test case data into standard test case data.
The above is displayed directly on the GUI page after the standard test case data is generated. In addition, after the test case data is converted into the standard test case data and stored in the version management case library, the case data can be called from the version management case library and displayed on a page. The generated cases are stored in a version management case library, a plurality of module cases are supported to be extracted according to needs, and regression testing in the version iteration process is facilitated.
Therefore, according to the embodiment of the present invention, there is also provided an apparatus 1000 for displaying the test case generated as above. As shown in fig. 10, the apparatus 1000 includes: a creation module 1010 for receiving a user instruction to create a parent node on a graphical user interface; and an extracting module 1020, configured to search the version management use case library in response to a click on a parent node, and extract standard use case data corresponding to the parent node onto the graphical user plane in a thinking graph.
The apparatus 1000 may further comprise: and the import module is used for importing the test cases corresponding to the keywords on the graphical user interface into the common case library. Specifically, when a certain use case keyword of a parent node of the mind map is right-clicked, for example, "login registration" or a user name node shown in fig. 7 is clicked, an "import" two word appears, and "import" is clicked, all child nodes behind the use case keyword can be imported into the public use case library.
The apparatus 1000 may further comprise: and the matching module is used for searching the public use case library, searching for use cases corresponding to the keywords on the thought guide graph, and displaying the use cases on the graphical user interface by the thought guide graph.
The various techniques described herein may be implemented in connection with hardware or software or, alternatively, with a combination of both. Thus, the methods and apparatus of the present invention, or certain aspects or portions thereof, may take the form of program code (i.e., instructions) embodied in tangible media, such as removable hard drives, U.S. disks, floppy disks, CD-ROMs, or any other machine-readable storage medium, wherein, when the program is loaded into and executed by a machine, such as a computer, the machine becomes an apparatus for practicing the invention.
In the case of program code execution on programmable computers, the computing device will generally include a processor, a storage medium readable by the processor (including volatile and non-volatile memory and/or storage elements), at least one input device, and at least one output device. Wherein the memory is configured to store program code; the processor is configured to execute the test case generation method of the present invention according to instructions in the program code stored in the memory.
By way of example, and not limitation, readable media may comprise readable storage media and communication media. Readable storage media store information such as computer readable instructions, data structures, program modules or other data. Communication media typically embodies computer readable instructions, data structures, program modules or other data in a modulated data signal such as a carrier wave or other transport mechanism and includes any information delivery media. Combinations of any of the above are also included within the scope of readable media.
In the description provided herein, algorithms and displays are not inherently related to any particular computer, virtual system, or other apparatus. Various general purpose systems may also be used with examples of this invention. The required structure for constructing such a system will be apparent from the description above. Moreover, the present invention is not directed to any particular programming language. It is appreciated that a variety of programming languages may be used to implement the teachings of the present invention as described herein, and any descriptions of specific languages are provided above to disclose preferred embodiments of the invention.
In the description provided herein, numerous specific details are set forth. It is understood, however, that embodiments of the invention may be practiced without these specific details. In some instances, well-known methods, structures and techniques have not been shown in detail in order not to obscure an understanding of this description.
Similarly, it should be appreciated that in the foregoing description of exemplary embodiments of the invention, various features of the invention are sometimes grouped together in a single embodiment, figure, or description thereof for the purpose of streamlining the disclosure and aiding in the understanding of one or more of the various inventive aspects. However, the disclosed method should not be interpreted as reflecting an intention that: that the invention as claimed requires more features than are expressly recited in each claim. Those skilled in the art will appreciate that the modules or units or components of the devices in the examples disclosed herein may be arranged in a device as described in this embodiment or alternatively may be located in one or more devices different from the devices in this example. The modules in the foregoing examples may be combined into one module or may be further divided into multiple sub-modules.
Those skilled in the art will appreciate that the modules in the device in an embodiment may be adaptively changed and disposed in one or more devices different from the embodiment. The modules or units or components of the embodiments may be combined into one module or unit or component, and furthermore they may be divided into a plurality of sub-modules or sub-units or sub-components. All of the features disclosed in this specification (including any accompanying claims, abstract and drawings), and all of the processes or elements of any method or apparatus so disclosed, may be combined in any combination, except combinations where at least some of such features and/or processes or elements are mutually exclusive. Each feature disclosed in this specification (including any accompanying claims, abstract and drawings) may be replaced by alternative features serving the same, equivalent or similar purpose, unless expressly stated otherwise.
Furthermore, those skilled in the art will appreciate that while some embodiments described herein include some features included in other embodiments, rather than other features, combinations of features of different embodiments are meant to be within the scope of the invention and form different embodiments. Furthermore, some of the described embodiments are described herein as a method or combination of method elements that can be performed by a processor of a computer system or by other means of performing the described functions. A processor having the necessary instructions for carrying out the method or method elements thus forms a means for carrying out the method or method elements. Further, the elements of the apparatus embodiments described herein are examples of the following apparatus: the apparatus is used to implement the functions performed by the elements for the purpose of carrying out the invention.
As used herein, unless otherwise specified the use of the ordinal adjectives "first", "second", "third", etc., to describe a common object, merely indicate that different instances of like objects are being referred to, and are not intended to imply that the objects so described must be in a given sequence, either temporally, spatially, in ranking, or in any other manner.
While the invention has been described with respect to a limited number of embodiments, those skilled in the art, having benefit of this description, will appreciate that other embodiments can be devised which do not depart from the scope of the invention as described herein. Furthermore, it should be noted that the language used in the specification has been principally selected for readability and instructional purposes, and may not have been selected to delineate or circumscribe the inventive subject matter.
Claims (10)
1. A test case generation method comprises the following steps:
acquiring a local requirement document, extracting keywords, conditions of the keywords and expected results, and respectively placing the keywords, the conditions of the keywords and the expected results into a case name input condition field, a keyword condition field and a case expected result field of a case event table, wherein the case event table is created in advance by a user and comprises the case name input condition field, the keyword condition field and the case expected result field;
positioning a module function method in a code document, acquiring a function method name and function parameters, and respectively placing the function method name and the function parameters into a method module name field and a parameter field in a code document case table, wherein the code document case table is created in advance by a user and comprises the method module name field and the parameter field;
extracting conditions of the keywords from the use case event list, and determining random conditions in intervals which are greater than, less than or equal to the conditions of the keywords;
assigning values to the function parameters obtained from the code document use case table, and performing orthogonal sequencing on random conditions of the keywords aiming at the assignment of each group of function parameters to obtain an orthogonal table object array, wherein the orthogonal table object array consists of a plurality of test cases;
and judging whether each test case in the orthogonal table object array is matched with a case expected result extracted from the case event table, screening the test cases in the orthogonal table object array matched with the case expected result, and forming a test case set.
2. The test case generation method of claim 1, further comprising:
and converting the test case into standard case data with a case title, a case step and an expected result as templates, wherein the case name is converted into the case title, each combination in the orthogonal table object array is converted into the case step, and the expected result of the case is converted into the expected result.
3. The test case generation method of claim 2, further comprising:
and storing the standard case data into a version management case library, wherein the version management case library is created by a user in advance and comprises a test case title name field, a test case step field and a test case expected result field.
4. A method of displaying test cases generated by the method of claim 3, comprising:
receiving a user instruction to create a parent node on a graphical user interface;
and responding to the click of the father node, searching the version management case library, and extracting the standard case data corresponding to the father node to the graphical user interface by using a thinking guide graph.
5. The method of displaying test cases of claim 4 further comprising:
and importing the test cases corresponding to the keywords on the graphical user interface into the common case library.
6. The method of displaying test cases of claim 4 further comprising:
and searching a public use case library, and displaying the use cases corresponding to the keywords on the graphical user interface by using a mind map.
7. A test case generation apparatus comprising:
the system comprises a first acquisition module, a second acquisition module and a third acquisition module, wherein the first acquisition module is used for acquiring a local requirement document, extracting keywords, conditions of the keywords and expected results, and respectively placing the keywords, the conditions of the keywords and the expected results into a case name input condition field, a keyword condition field and a case expected result field of a case event table, and the case event table is created in advance by a user and comprises the case name input condition field, the keyword condition field and the case expected result field;
the second acquisition module is used for positioning a module function method in the code document, acquiring a function method name and function parameters, and respectively placing the function method name and the function parameters into a method module name field and a parameter field in a code document case table, wherein the code document case table is created by a user in advance and comprises a method module name field and a parameter field;
the extraction module is used for extracting the conditions of the keywords from the use case event table and determining the random conditions in the interval which is greater than, less than or equal to the conditions of the keywords;
the orthogonal sorting module is used for assigning values to the function parameters obtained from the code document use case table, and carrying out orthogonal sorting on the random condition of the key words aiming at the assignment of each group of function parameters to obtain an orthogonal table object array, wherein the orthogonal table object array consists of a plurality of test cases;
and the screening module is used for judging whether each test case in the orthogonal table object array is matched with the case expected result extracted from the case event table or not, screening the test cases in the orthogonal table object array matched with the case expected result, and forming a test case set.
8. An apparatus for displaying test cases generated by the method of claim 3, comprising:
the creation module is used for receiving a user instruction so as to create a father node on the graphical user interface;
and the extraction module is used for responding to clicking of the father node, searching the version management case library, and extracting the standard case data corresponding to the father node to the graphic user plane by using a thinking guide graph.
9. A computing device, comprising:
at least one processor and a memory storing program instructions;
the program instructions, when read and executed by the processor, cause the computing device to perform the test case generation method of any of claims 1-3 or the method of displaying test cases of any of claims 4-6.
10. A readable storage medium storing program instructions which, when read and executed by a computing device, cause the computing device to perform the test case generation method of any of claims 1-3 or the method of displaying test cases of any of claims 4-6.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210228832.3A CN114328276B (en) | 2022-03-10 | 2022-03-10 | Test case generation method and device, and test case display method and device |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210228832.3A CN114328276B (en) | 2022-03-10 | 2022-03-10 | Test case generation method and device, and test case display method and device |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN114328276A true CN114328276A (en) | 2022-04-12 |
| CN114328276B CN114328276B (en) | 2022-05-20 |
Family
ID=81033290
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202210228832.3A Active CN114328276B (en) | 2022-03-10 | 2022-03-10 | Test case generation method and device, and test case display method and device |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN114328276B (en) |
Cited By (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114860582A (en) * | 2022-04-14 | 2022-08-05 | 中国电子科技集团公司第十五研究所 | Web page test auxiliary method and system |
| CN114880242A (en) * | 2022-06-08 | 2022-08-09 | 北京百度网讯科技有限公司 | Test case extraction method, device, equipment and medium |
| CN116185883A (en) * | 2023-04-28 | 2023-05-30 | 阿里云计算有限公司 | Test case generation method, test system, device, equipment and medium |
| CN116389485A (en) * | 2023-06-05 | 2023-07-04 | 上海朗力半导体有限公司 | Data center system and method, map node, reduce node, equipment and chip |
Citations (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20060010426A1 (en) * | 2004-07-09 | 2006-01-12 | Smartware Technologies, Inc. | System and method for generating optimized test cases using constraints based upon system requirements |
| CN104484269A (en) * | 2014-11-27 | 2015-04-01 | 北京广利核系统工程有限公司 | Method for automatically generating testing script |
| US20150278075A1 (en) * | 2014-03-26 | 2015-10-01 | Mckesson Financial Holdings | Apparatuses, methods, and computer program products for conducting automated tests |
| CN106502896A (en) * | 2016-10-21 | 2017-03-15 | 武汉斗鱼网络科技有限公司 | A kind of generation method of function test code and device |
| CN109254907A (en) * | 2018-08-03 | 2019-01-22 | 挖财网络技术有限公司 | A kind of interface testing report-generating method and system based on Java |
| CN110399294A (en) * | 2019-06-26 | 2019-11-01 | 平安科技（深圳）有限公司 | Method for generating test case, device, computer equipment and storage medium |
| CN112231230A (en) * | 2020-11-12 | 2021-01-15 | 腾讯科技（深圳）有限公司 | Test case management method and device, electronic equipment and storage medium |
| CN112579466A (en) * | 2020-12-25 | 2021-03-30 | 深圳证券交易所 | Test case generation method and device and computer readable storage medium |
-
2022
- 2022-03-10 CN CN202210228832.3A patent/CN114328276B/en active Active
Patent Citations (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20060010426A1 (en) * | 2004-07-09 | 2006-01-12 | Smartware Technologies, Inc. | System and method for generating optimized test cases using constraints based upon system requirements |
| US20150278075A1 (en) * | 2014-03-26 | 2015-10-01 | Mckesson Financial Holdings | Apparatuses, methods, and computer program products for conducting automated tests |
| CN104484269A (en) * | 2014-11-27 | 2015-04-01 | 北京广利核系统工程有限公司 | Method for automatically generating testing script |
| CN106502896A (en) * | 2016-10-21 | 2017-03-15 | 武汉斗鱼网络科技有限公司 | A kind of generation method of function test code and device |
| CN109254907A (en) * | 2018-08-03 | 2019-01-22 | 挖财网络技术有限公司 | A kind of interface testing report-generating method and system based on Java |
| CN110399294A (en) * | 2019-06-26 | 2019-11-01 | 平安科技（深圳）有限公司 | Method for generating test case, device, computer equipment and storage medium |
| CN112231230A (en) * | 2020-11-12 | 2021-01-15 | 腾讯科技（深圳）有限公司 | Test case management method and device, electronic equipment and storage medium |
| CN112579466A (en) * | 2020-12-25 | 2021-03-30 | 深圳证券交易所 | Test case generation method and device and computer readable storage medium |
Cited By (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114860582A (en) * | 2022-04-14 | 2022-08-05 | 中国电子科技集团公司第十五研究所 | Web page test auxiliary method and system |
| CN114860582B (en) * | 2022-04-14 | 2024-01-09 | 中国电子科技集团公司第十五研究所 | Web page test auxiliary method and system |
| CN114880242A (en) * | 2022-06-08 | 2022-08-09 | 北京百度网讯科技有限公司 | Test case extraction method, device, equipment and medium |
| CN116185883A (en) * | 2023-04-28 | 2023-05-30 | 阿里云计算有限公司 | Test case generation method, test system, device, equipment and medium |
| CN116389485A (en) * | 2023-06-05 | 2023-07-04 | 上海朗力半导体有限公司 | Data center system and method, map node, reduce node, equipment and chip |
| CN116389485B (en) * | 2023-06-05 | 2023-08-15 | 上海朗力半导体有限公司 | Data center system and method, map node, reduce node, equipment and chip |
Also Published As
| Publication number | Publication date |
|---|---|
| CN114328276B (en) | 2022-05-20 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN114328276B (en) | Test case generation method and device, and test case display method and device | |
| US10872005B1 (en) | Fixed length message generation tool | |
| US9495347B2 (en) | Systems and methods for extracting table information from documents | |
| CN109871311B (en) | Method and device for recommending test cases | |
| CN111736840A (en) | Compiling method and running method of applet, storage medium and electronic equipment | |
| KR101554424B1 (en) | Method and apparatus for auto generation of test case | |
| CN113138927B (en) | Software function test method and device | |
| CN110837356B (en) | Data processing method and device | |
| CN108694108B (en) | iOS crash data classification and statistics method and device | |
| US8745521B2 (en) | System and method for annotating graphical user interface | |
| JP2018116496A (en) | Difference detection device and program | |
| CN109872230B (en) | Test method and device of financial data analysis system, medium and electronic equipment | |
| CN110688111A (en) | Configuration method, device, server and storage medium of business process | |
| CN104933096B (en) | Abnormal key recognition methods, device and the data system of database | |
| CN113792138B (en) | Report generation method and device, electronic equipment and storage medium | |
| CN113448869B (en) | Method and device for generating test case, electronic equipment and computer readable medium | |
| JP6723976B2 (en) | Test execution device and program | |
| CN113051262A (en) | Data quality inspection method, device, equipment and storage medium | |
| WO2020085129A1 (en) | Test data generation device, test data generation method, and program | |
| CN116775488A (en) | Abnormal data determination method, device, equipment, medium and product | |
| US20200311125A1 (en) | Information processing apparatus and non-transitory computer readable medium storing program | |
| Ceballos Delgado et al. | FADE: A forensic image generator for android device education | |
| CN114115831A (en) | Data processing method, device, equipment and storage medium | |
| CN114385155A (en) | vue project visualization tool generation method, device, equipment and storage medium | |
| JP5705681B2 (en) | Information processing apparatus, data migration tool generation method and program |
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 |