KR101989311B1 - Apparatus and method for generating test scripts for testing embedded system - Google Patents

Abstract

An apparatus for generating a test script for testing an embedded system and a method thereof, the apparatus comprising: a test script generation unit for generating a test script for testing an embedded system according to an embodiment of the present invention, A check list generating unit for generating a check list; An instruction dictionary generating unit for generating an instruction dictionary in which an input value to the test instruction of the check list is defined; And a test script generator for generating a test script by generating a combination of operation modes of the checklist item and searching for the test command included in the operation mode in the command dictionary.

Description

[0001] APPARATUS AND METHOD FOR GENERATING TEST SCRIPTS FOR TESTING EMBEDDED SYSTEM [0002]

The present invention relates to an apparatus and a method for generating a test script for testing an embedded system, and more particularly, to a system and method for generating a systematic check list, generating a command dictionary defined for a test command of a check list, The present invention relates to an apparatus and method for generating a test script for testing an embedded system for shortening the time for generating a test script for testing of an embedded system and reducing an error by automatically generating a test script by referring to an instruction dictionary.

Embedded systems are used in various fields such as mobile devices, household appliances, and military weapons, and are performing more and more complex functions than in the past. As a result, the software that performs the functions of the system is becoming more complicated. Much of the error that occurs when an embedded system is operating is a software error, and it can not bring about catastrophic failure or perform a given task correctly in a system that performs mission critical tasks such as an aircraft or a military weapon. Software testing of these complex embedded systems is becoming a necessity, not an option. There are many test techniques to improve the reliability of such embedded software.

One common test technique is to use a checklist. The checklist includes items to be tested by the engineer's knowledge of the development system, past experience, user feedback, and the like. These checklists are lists of conditions and conditions that should be tested to check the functionality of the test target. The general checklist lists what to test, but the data that gives the actual input to the system under test may be determined manually by the tester with reference to the checklist.

An experience-based checklist is used to test the "items an embedded system must" that are included in the checklist. However, some industries (such as NASA, weapon control systems, and automotive control systems) require that they do not do what they should not do. However, it is very difficult for an engineer to create an 'item not to do' from a checklist to match the test strategy. In particular, the more items the checklist contains, the more difficult it is for engineers to create test cases.

An engineer uses some of the experience items to generate some items that should not be done from the checklist, but it is not easy to create an item that fits the test strategy.

The conventional check list generation method has the following limitations. First, the results can vary depending on the tester's mistakes or subjective thoughts. It is also difficult to create a test case if there are many items in the checklist. And because the checklist items are much different from the actual test cases, we need to consider system input conditions and so on to make checklist items into test cases, which may require a lot of effort and time to analyze.

Therefore, engineers need to create test cases and test scripts according to a standardized checklist format, rather than manually creating a checklist for testing the embedded system, thereby shortening the test script generation time and reducing occurrence errors .

On the other hand, in the related art, a technique for automatically generating the necessary script code in the embedded development environment is proposed in Korean Patent Application Publication No. 10-2010-0065081 entitled " Method for Automatic Generation of Embedded System and Build Script Program for Supporting Embedded Development Environment & .

Korean Patent Publication No. 10-2010-0065081 (June 15, 2010)

It is an object of the present invention to provide a method and system for testing embedded systems by generating a structured checklist, generating a command dictionary defined for the test command of the checklist, and automatically generating a test script by referring to the checklist and the command dictionary The present invention provides an apparatus and method for generating a test script for testing an embedded system, in order to shorten the time for generating a test script and reduce an error.

It is another object of the present invention to provide an apparatus and method for generating a test script for testing an embedded system that automatically generates a test script capable of detecting an error in an embedded system in various ways according to a test script generation method.

It is also an object of the present invention to provide an apparatus and method for generating a test script for testing an embedded system that generates a test script capable of testing not only contents written in a list of checklists but also an operation that may cause an error .

An apparatus for generating a test script for testing an embedded system according to an exemplary embodiment of the present invention includes a check list generator for generating a check list in which one or more check list items are structured; An instruction dictionary generating unit for generating an instruction dictionary in which an input value to the test instruction of the check list is defined; And a test script generator for generating a test script by generating a combination of operation modes of the check list item and searching for the test command included in the operation mode in the command dictionary, A combination can be created by arranging the operation modes in a double permutation manner.

The apparatus for generating a test script for testing an embedded system according to an exemplary embodiment of the present invention includes a sequence for sequentially generating the operation modes and generating a sequence file indicating a connection relationship between the operation modes And a file generating unit.

The check list generator generates the check list in a systematic structure according to scenario flow and scenario conditions based on use case specification creation.

The item of the checklist includes an operation mode, a function classification, a condition, a function description, and a test command. The operation mode is an item indicating a series of operation flows defined by a user for testing a specific function according to a test strategy, Wherein the function classification is an execution function of each of the operation modes, and includes an entry condition, an end condition, and a main operation item, the condition being set to the entry condition or the termination condition, And the test command indicates an actual test command for testing the function of the check list column.

The test script generator sequentially arranges the operation modes in a predetermined order in the sequence file to generate a combination.

delete

The test script generator generates a combination by arranging the operation modes in a triple permutation manner.

The test script generation unit generates the test script for randomly selecting a test command in the operation mode and testing the random operation for an unintended scenario.

Meanwhile, a test script generation method for testing an embedded system according to an exemplary embodiment of the present invention includes generating a check list in which one or more check list items are structured; Generating an instruction dictionary in which an input value to the test instruction of the checklist is defined; And generating a test script by generating a combination of operation modes of the checklist item and searching for a test command included in the operation mode in the command dictionary, You can create a combination by listing modes in double permutation.

The present invention generates a structured checklist, generates a command dictionary defined for the test command of the checklist, and automatically generates a test script by referring to the checklist and the command dictionary to generate a test script for testing of the embedded system It is possible to shorten the time to generate and reduce errors.

In addition, the present invention can create a systematic test case using a checklist.

In addition, the present invention can automatically generate a test script capable of detecting an error in the embedded system in various ways according to a test script generation method.

In addition, the present invention can generate a test script that can test not only the contents written in the list of the check list but also the operation that may possibly cause an error.

1 is a block diagram of a test script generating apparatus for testing an embedded system according to an embodiment of the present invention;
2 is a diagram showing an example of a check list to which the present invention is applied,
3 is a diagram showing an example of a test command of a check list to which the present invention is applied,
4 is a diagram illustrating a menu provided by a test engineer in a test script generating unit according to the present invention,
5 is a diagram illustrating a test script generation method for testing an embedded system according to an embodiment of the present invention.

For a better understanding of the present invention, a preferred embodiment of the present invention will be described with reference to the accompanying drawings. The embodiments of the present invention may be modified into various forms, and the scope of the present invention should not be construed as being limited to the embodiments described in detail below. The present embodiments are provided to enable those skilled in the art to more fully understand the present invention. Therefore, the shapes and the like of the elements in the drawings can be exaggeratedly expressed to emphasize a clearer description. It should be noted that in the drawings, the same members are denoted by the same reference numerals. Detailed descriptions of well-known functions and constructions which may be unnecessarily obscured by the gist of the present invention are omitted.

FIG. 1 is a block diagram of an apparatus for generating a test script for testing an embedded system according to an embodiment of the present invention. FIG. 2 is a diagram illustrating an example of a check list to which the present invention is applied. And shows an example of a test command of an applied check list.

As shown in FIG. 1, a test script generating apparatus (hereinafter referred to as "test script generating apparatus") 100 for testing an embedded system according to an embodiment of the present invention generates test script based on a check list In addition to reducing manual errors by engineers, you can test various combinations of modes that are difficult to test with an existing checklist. That is, the test script generating apparatus 100 generates a test script to be inputted to the embedded system in order to perform an actual test based on the check list.

Here, the test script is a form in which a test case is converted into a physical value in order to be applied to an actual embedded system. In this case, it is used in combination with a test case.

The test script generation apparatus 100 includes a check list generation unit 110, a command dictionary generation unit 120, a sequence file generation unit 130, and a test script generation unit 140.

The check list generating unit 110 generates a check list in which check list items generally used are structured and provides the check list to the test script generating unit 140. That is, the check list generating unit 110 generates a check list in a systematic structure according to the scenario flow and the scenario condition based on the use case specification creation. Here, the scenario flow consists of a basic flow in which the embedded system normally performs the requested function of the user and an alternative flow that should be appropriately replaced in the case of failure in performing the requested function. The scenario condition consists of a precondition for the start of use case execution and a postcondition that must be satisfied after the execution is completed.

These checklists contain information that can be used to check whether the proper functions for checking system errors are working properly.

Referring to FIG. 2, the check list includes an operation mode 111, a function classification 112, a condition 113, a function description 114, and a test command 115 ≪ / RTI >

The 'operation mode' 111 and the 'function description' 114 are irrelevant to the actual test script generation and are used to inform the test engineer of the test information.

An 'operation mode' 111 is an item for an operation mode name, and is a series of operation flows defined by the user for testing a specific function according to a test strategy. For example, the 'operation mode' 111 can be classified into one independent operation group as a whole, such as an initial mode, a general mode, and a special mode. Therefore, other operations of the embedded system can be tested with different classification combinations.

The 'function classification' 112 is a function performed in each operation mode and is composed of 'entry condition', 'termination condition' and 'main operation' item. Specifically, the 'entry condition' is a condition that must be satisfied in order to enter the corresponding mode. You can enter the 'main action' only if you meet some or all of the 'entry conditions'. A 'main action' is a series of actions that must always be performed. 'Termination condition' is an event or condition for terminating the mode. If some or all of the conditions are satisfied, such as 'entering condition', the corresponding mode is terminated. Therefore, each mode is performed under the condition of entry → main operation → termination condition.

'Condition' 113 is a space in which a condition is set in 'entry condition' or 'termination condition', and conditions such as 'AND' and 'OR' may be set. 'AND' is a condition that all the created conditions must be satisfied, and 'OR' is a condition that only one of the created conditions may be satisfied. The condition may consist of a combination satisfying condition coverage, decision coverage, and modified condition / decision coverage (MC / DC).

A 'function description' (114) indicates what each function should perform.

The 'test command' 115 indicates an actual test command (that is, a command) for testing the function of the corresponding column of the check list.

The command dictionary generation unit 120 generates a command dictionary, which is a document in which an input value to the test command of the checklist is defined, and provides the command dictionary to the test script generation unit 140. Here, the command dictionary is a set of test commands in the checklist. In the test command, which is a unit function to be executed by the embedded system, physical values of all inputs applied to the embedded system are defined for each time zone.

Table 1 below shows an example of a test input composed of values of input signals applied every 5 msec from the moment when a test instruction is executed in an embedded system having N input signals (i1, i2, ..., iN). In this case, all of the N inputs are needed to test the actual embedded system.

Time
(msec) Input signal value i1 i2 ... iN 0 2 1.5 ... T 5 3 4.1 ... F 10 2 4.4 ... T ... ... ... ... ... 30 4 3.7 ... T

The time can be defined as a unit of time in which the input is applied. The time interval is the relative time at which the input is applied. The input signal may be a prime number, an integer, a true / false value, etc., as defined beforehand.

However, the actual test command does not define all the input signal values but defines only the changed values from the previous input signal values, and the input signals that are not defined in the remaining test commands retain the previous input signal values. The initial input signal value is defined in advance.

Referring to FIG. 3, the input information of the embedded system for generating a test script includes 'command' 121, 'group' 122, 'time' 123, Input '124.

The 'command' 121 represents one of the test commands in the checklist.

The 'group' 122 is an identifier of a variant of the command. For example, '1' in the 'group' of 'engine sensor normal' indicates a system input (that is, the engine sensor normal) satisfying the condition of the engine sensor and a system input Sensor abnormal) are set as one group. If the 'engine sensor normal' command is selected under the TRUE condition, the 'engine sensor abnormal' command may be selected under the FALSE condition. Thus, the 'group' 122 is different for each command, and one command has a maximum of two groups. That is, the group satisfying the condition and the group not satisfying the condition. An instruction without a group has one input flow (that is, a group that satisfies a condition).

The 'time' (123) defines the time at which the system input is applied. This 'time' 123 refers to the relative time from the time the command is executed.

The 'system input' 124 indicates a system input value that changes when the corresponding command is executed. If not changed, the previous input state value is maintained.

Referring to Table 2, Table 2 below shows a test command 'A sensor ERR' for testing an embedded system. In this case, the embedded system may be provided with five input signals A_sensor, B_sensor_N1, B_sensor_N2, C_sensor_N1, and C_sensor_N2. If the initial values of the five input signals are set to -70, 40, 40, 0 and 0, the test command 'A sensor ERR' indicates the input signals as shown in Table 2 below from the starting point (Time = 0) 70, 80, and 500 sec, respectively, in the embedded system.

command Group TIME A_sensor B_sensor_N1 C_sensor_N1 C_sensor_N2 A sensor ERR 0 -70 20 -15 45 70 -29 -5 -5 80 -15 10 15 15 500

The signal value of 'A_sensor' is '-70' at the execution time (0 second), and the signal values of the remaining B_sensor_N1, C_sensor_N1, and C_sensor_N2 are maintained for 20 seconds.

The signal value of 'A_sensor' is changed to '-15' and the signal value of 'B_sensor_N1' is changed to '45' in 20 seconds, and the remaining signal values are maintained in the previous state. In this case, it is held for 50 seconds until the next input, 70 seconds.

Change the signal value of 'A_sensor' to '-29' in 70 seconds, and change the signal value of 'C_sensor_N1' and 'C_sensor_N2' to '-5'. In this case, the next input is held for 10 seconds to 80 seconds.

Change the signal value of 'A_sensor' to '-15' in 80 seconds, change the signal value of 'B_sensor' to '10', change the signal value of 'C_sensor_N1' and 'C_sensor_N2' to '15' . In this case, the test script generation for the 'A sensor ERR' command is completed after it is maintained for 420 seconds until 500 seconds. The signal value of 'B_sensor_N2' keeps the initial value from 0 to 500 seconds.

Table 3 below shows the variable values actually input according to Table 2 above.

Time (sec) Input signal value A_sensor B_sensor_N1 B_sensor_N2 C_sensor_N1 C_sensor_N2 0 -70 40 40 0 0 20 -15 45 40 0 0 70 -29 45 40 -5 -5 80 -15 10 40 15 15 500 -15 10 40 15 15

The sequence file generation unit 130 defines a simple grammar for sequentially generating modes and generates a sequence file indicating a connection relationship between operation modes and provides the sequence file to the test script generation unit 140. That is, the test script generation unit 140 generates test scripts in the order determined in the sequence file. In this case, the test script generator 140 generates a test script using the sequence file when generating the test script in a sequential manner.

Here, the sequence file is defined by the grammar using the three symbols {'/', '_', ';'}. That is, the linkage between modes is listed as '/', the completion of one grammar is represented by ';', and the specific termination condition or entry condition designation is indicated by '_' in the mode.

Table 4 shows an example of creating a sequence file.

"Initial Mode / Normal Mode"(*);
"Operation mode A_DERR / Special mode # 1";

"Initial mode / normal mode" means that the initial mode and the normal mode must be sequentially performed. Next, "operation mode A" and "special mode # 1" are sequentially performed. However, the "operation mode A_DERR" means that, among various conditions that can be terminated when the operation mode A ends, it should be terminated with a DERR condition.

The test script generating unit 140 generates a test script (or a test case) in cooperation with the check list generating unit 110, the instruction dictionary generating unit 120, and the sequence file generating unit 130. That is, the test script generator 140 refers to the test command, the command dictionary, and the sequence file in the check list to generate a test script.

The test script generation unit 140 performs a check list to sequentially execute a test command of the check list from the top. The test script generation unit 140 executes the input of the test command according to the input sequence for the test command defined in the command dictionary. The test script generation unit 140 searches the instruction dictionary for the corresponding test instruction, and generates a test script by matching the signal value of the corresponding instruction to the defined time. Here, the execution time interval between the test instructions follows a preset time interval, and the test instruction must be present in the instruction dictionary.

In addition, the test script generation unit 140 generates various test scripts by combining the previously defined operation modes. One operation mode is a series of functions for a specific operation. In order to test whether the embedded system operates normally in various environments, a test script made up of various operation mode combinations is essential. Various combinations of test commands constituting the operation mode are possible, but depending on the combination of test commands, the embedded system may not be reachable. Here, only a case of generating a test script by a combination of operation modes will be described.

In other words, the test script generation unit 140 combines the operation modes of the check list items, and searches the instruction dictionary included in the operation mode in the instruction dictionary to generate the test script.

Hereinafter, the test script generation method of the test script generation unit 140 will be described.

First, the test script generation unit 140 generates test scripts in a sequential manner.

In this case, the test script generation unit 140 appropriately arranges various operation modes as necessary to generate a test script.

The sequential method is mainly used to test whether the function operation in each mode is executed properly, and the experience-based scenario of the tester is created and created. Accordingly, the test script generation unit 140 generates a combination that can be tested with a focus on test conditions that vary in operation according to conditions inside the operation mode.

In this way, the test script generation unit 140 sequentially arranges the operation modes according to scenarios with the operation mode created in the check list as a basic unit, thereby generating a combination. The internal logic of each operation mode is performed in the order of "entry condition", "main operation" and "termination condition", and a test command for each function is generated.

Here, the test script generation unit 140 receives the sequence files from the sequence file generation unit 130, and generates the test scripts in a predetermined sequence in the sequence file.

In this manner, when the sequential scheme is applied, the test script generation unit 140 generates test scripts in the order of the operation modes indicated in the check list. At this time, when the sequence file is input from the sequence file generation unit 130, the test script generation unit 140 generates test scripts in the order of the operation modes defined in the sequence file, and when the operation mode is not defined in the sequence file Create them in the order defined in the checklist.

The sequential method creates a sequence of operation modes desired by the user and generates a test script according to the created sequence. In addition, 'end condition' and 'entry condition' that should be performed in each operation mode can be specified. The sequential approach can give many empirical aspects to the user.

Next, a description will be made of a case where the test script generating unit 140 generates a test script in a double permutation manner.

The sequential method described above is a method of generating a test script that focuses on the main operation test of a specific operation mode. However, the sequential method can not generate a combination that can determine the accuracy of whether or not the mode is entered according to the combination of the "entry condition" and the "termination condition" of different mode operations. That is, the sequential method is a method in which the embedded system has various operation modes, and if there is at least one "entry condition" or "end condition" of each operation mode, whether the entry from one mode to another mode is good or various " It is difficult to generate a test script for judging whether it operates normally under the "end condition ". For this purpose, the double permutation method generates a test script for testing the operation of the embedded system when two specific modes are executed in sequence.

The test script generation unit 140 generates a test script using the listed combination of two possible operation modes.

That is, if there are N modes in the embedded system, the combination of the two possible modes is " _N P ₂ " (i.e., N Permutation 2). For example, ₃ P ₂ = 6 (ie, AB, BA, AC, CA, BC, CB) for the three modes A, B and C. The case in which two of these modes can not be sequentially performed is subtracted. The resulting combination is listed so that the ending mode of the previous combination is the starting mode of the next combination. For example, the possible listing combination would be 'ABBCCAACCBBA'. If one of the listed combinations is the same, the test script is generated using the 'ABCACBA' mode operation combination. In this case, the total number of test modes can be reduced.

In this way, when the double permutation scheme is applied, the test script generation unit 140 creates an operation mode combination and adds a condition combination policy (" For example, MC / DC).

In the double permutation method, a test script suitable for testing an error according to the operation order of each operation mode is generated. The 'entry condition' and 'termination condition' of the operation mode are generated in various combinations according to the coverage policy. In addition, an operation mode having a plurality of 'termination conditions' can perform test commands of all the 'termination conditions'.

In addition, the test script generator 140 may generate a test script using a triple permutation scheme. The triple permutation method generates a test script for testing the operation of the embedded system when three specific modes are executed in sequence. The triple permutation scheme excludes three modes, such as the double permutation scheme, that can not be performed sequentially.

In this way, when the triple permutation scheme is applied, the test script generation unit 140 generates the test script by combining the three operation modes, while generating the double-permutation scheme.

Next, the case where the test script generating unit 140 generates a test script in a random manner will be described. The test script generating unit 140 randomly selects a test command in the operation mode without considering the operation mode and generates a test script for testing the random operation for the unintended scenario. When generating the test script in a random manner, the test script generating unit 140 can determine the time of the instruction and the total number of instructions in the test script. The instruction time can be changed depending on the characteristics of the product to be tested when the corresponding instruction is input.

In this way, when the random method is applied, the test script generating unit 140 generates a test script by randomly selecting an instruction according to the number of instructions NUM to be generated and the time interval between instructions (wait).

The random method creates a test script by randomly selecting the test command written in the checklist, and the random test script can detect an error by random operation.

On the other hand, the test script generator 140 may notify the expected test time indicating the total time taken to perform the actual test from the generated test script.

4 is a diagram illustrating a menu provided by a test engineer in a test script generating unit according to the present invention.

The test script generation unit 140 generates the test script 144 according to the operation mode and the generation method using the check list 141, the command dictionary 142 and the sequence file 143. [ At this time, when the check list 141 is received, the test script generating unit 140 may display a selectable item of the operation mode that can be generated in the 'Checklist' 145 and provide the selected item to the test engineer.

Meanwhile, in the case of the random method, the test script generation unit 140 may input 'NUM' 146, which is the number of instructions that can be generated, and 'wait' 147, which is a command time interval. The test script generating unit 140 may display a test expected time 148 for generating a test script.

5 is a diagram illustrating a test script generation method for testing an embedded system according to an embodiment of the present invention.

First, the test script generating apparatus 100 generates a check list in which check list items are structured (S201). At this time, the test script generating apparatus 100 can generate a check list in a systematic structure according to the scenario flow and scenario conditions based on the use case statement creation.

Then, the test script generating apparatus 100 generates an instruction dictionary in which an input value to the test instruction of the check list is defined (S202).

Then, the test script generating apparatus 100 refers to the check list and the command dictionary, and generates a test script according to the test script generating method (S203). That is, the test script generating apparatus 100 generates a combination of operation modes of the check list items, and generates a test script by searching for a test command included in the operation mode in the command dictionary. At this time, the test script generating apparatus 100 generates a test script according to one of a sequential method, a double permutation method, a triple permutation method, and a random method. At this time, in the case of using the sequential method, the test script generating apparatus 100 generates and prepares a sequence file indicating a connection relationship between operation modes before generating the test script.

It will be apparent to those skilled in the art that various modifications and equivalent arrangements may be made therein without departing from the spirit and scope of the invention as defined by the appended claims. Accordingly, it is to be understood that the present invention is not limited to the above-described embodiments. Accordingly, the true scope of the present invention should be determined by the technical idea of the appended claims. It is also to be understood that the invention includes all modifications, equivalents, and alternatives falling within the spirit and scope of the invention as defined by the appended claims.

110: Checklist generation unit 120: Instruction dictionary generation unit
130: Sequence file generation unit 140: Test script generation unit

Claims (15)

A checklist generator for generating a checklist in which one or more checklist items are structured;
An instruction dictionary generating unit for generating an instruction dictionary in which an input value to the test instruction of the check list is defined; And
And a test script generator for generating a test script by generating a combination of operation modes of the checklist item and searching for the test command included in the operation mode in the command dictionary,
Wherein the test script generating unit comprises:
And generating a combination by listing the operation modes in a double permutation manner.
The method according to claim 1,
A sequence file generation unit for generating a sequence file indicating a connection relationship between the operation modes by defining a syntax for sequentially generating the operation modes;
Further comprising: a test script generator for testing the embedded system.
The method according to claim 1,
Wherein the check list generator comprises:
Wherein the checklist is generated in a systematic structure according to scenario flow and scenario conditions based on use case specification creation.
The method according to claim 1,
The item of the checklist includes an operation mode, a function classification, a condition, a function description, and a test command,
The operation mode is an item indicating a series of operation flows defined by a user for testing a specific function according to a test strategy, and the function classification is an operation function of each operation mode, and includes an entry condition, an end condition, and a main operation item Wherein the condition is set to the entry condition or the termination condition, the function description indicates contents to be performed by each function, and the test command is an embedded test result indicating an actual test instruction for testing the function of the check list column A test script generator for testing the system.
3. The method of claim 2,
Wherein the test script generating unit comprises:
And generating a combination by sequentially listing the operation modes according to a predetermined order in the sequence file.
delete The method according to claim 1,
Wherein the test script generating unit comprises:
And generating a combination by listing the operation modes in a triple permutation manner to generate a test script for testing the embedded system.
The method according to claim 1,
Wherein the test script generating unit comprises:
And generating the test script for randomly selecting a test command in the operation mode and testing the random operation for an unintended scenario.
Generating a structured checklist of one or more checklist items;
Generating an instruction dictionary in which an input value to the test instruction of the checklist is defined; And
Generating a test script included in the operation mode by searching for the test command included in the operation mode in the command dictionary,
Wherein the generating the test script comprises:
And generating a combination by arranging the operation modes in a double permutation manner to generate a test script for testing the embedded system.
10. The method of claim 9,
Generating a sequence file indicating a connection relationship between the operation modes by defining a syntax for sequentially generating the operation modes before generating the test script;
And generating a test script for testing the embedded system.
10. The method of claim 9,
Wherein the checklist is generated in a systematic structure according to scenario flow and scenario conditions based on use case specification creation.
11. The method of claim 10,
Wherein the generating the test script comprises:
And generating a combination by sequentially listing the operation modes according to a predetermined order in the sequence file to generate a test script for testing the embedded system.
delete 10. The method of claim 9,
Wherein the generating the test script comprises:
And generating a combination by arranging the operation modes in a triple permutation manner to generate a test script for testing the embedded system.
10. The method of claim 9,
Wherein the generating the test script comprises:
Generating a test script for testing a random operation for an unintended scenario by randomly selecting a test command in the operation mode.

Images