JP7529356B2 - Verification program, verification method, and information processing device - Google Patents

Description

The present invention relates to a verification program, a verification method, and an information processing device.

In recent years, the migration of GUI applications has become more common, driven by the trend toward open systems and compatibility with smart devices. In some cases, the migration of GUI applications requires the migration of screen definitions to a different format. In such cases, for example, the screen configuration after migration is verified by comparing the screens before and after the migration.

Prior art involves comparing modified basic screen definition data with customer screen definition data, extracting parts of the modified basic screen definition data that differ from the customer screen definition data, reflecting the extracted parts in an identifiable manner in the customer screen definition data, generating modified customer screen definition data, and displaying a screen composed of the customer screen definition data and a screen composed of the modified customer screen data in a comparable manner.

JP 2006-276953 A

However, with conventional technology, there is a problem in that verifying the screen configuration that accompanies a system migration requires a lot of work and time. For example, when an operator visually compares the screen before and after the migration to determine whether there are any errors in the screen configuration, this can lead to missed checks and increases the workload and time required for verification.

In one aspect, the present invention aims to make it possible to easily verify screen configurations following a system migration.

In one embodiment, a verification program is provided that extracts information about a plurality of elements constituting each screen, for a first screen of a first system and a second screen of a second system to which the first system is migrated, from a screen definition file that defines the configuration of the screen, and performs a normalization process for each of the screens that makes it possible to distinguish the type of each of the plurality of elements, the element name of each of the plurality of elements, and the relative positional relationships between the elements of the plurality of elements according to a predetermined normalization rule based on the extracted information about the plurality of elements, removes differences in display shape and size between the screens of each of the plurality of elements, and outputs the results of the normalization process performed for each of the screens.

One aspect of the present invention has the effect of making it possible to easily verify screen configurations following a system migration.

FIG. 1 is an explanatory diagram showing an example of a verification method according to an embodiment. FIG. 2 is a block diagram showing an example of the hardware configuration of the information processing device 101. FIG. 3 is a block diagram showing an example of the functional configuration of the information processing device 101. FIG. 4 is an explanatory diagram showing a screen image of the first screen. FIG. 5 is an explanatory diagram showing a screen image of the second screen. FIG. 6 is an explanatory diagram showing a specific example of an HTML file. FIG. 7 is an explanatory diagram showing an example of the data structure of the screen definition information. FIG. 8 is an explanatory diagram illustrating an example of the data structure of the regular element table. FIG. 9 is an explanatory diagram (part 1) showing an example of the normalization process. FIG. 10 is an explanatory diagram (part 2) showing an example of the normalization process. FIG. 11 is an explanatory diagram (part 3) showing an example of the normalization process. FIG. 12 is an explanatory diagram (part 4) showing an example of the normalization process. FIG. 13 is an explanatory diagram (part 5) showing an example of the normalization process. FIG. 14 is an explanatory diagram showing an example of output of screen configuration information. FIG. 15 is an explanatory diagram showing an example of another normalization rule. FIG. 16 is an explanatory diagram showing a specific example of the screen definition information for the first screen. FIG. 17 is an explanatory diagram (part 1) showing an example of the normalization process of the first screen. FIG. 18 is an explanatory diagram (part 2) showing an example of the normalization process of the first screen. FIG. 19 is an explanatory diagram (part 3) showing an example of the normalization process of the first screen. FIG. 20 is an explanatory diagram (part 4) showing an example of the normalization process of the first screen. FIG. 21 is an explanatory diagram (part 5) showing an example of the normalization process of the first screen. FIG. 22 is an explanatory diagram (part 6) showing an example of the normalization process of the first screen. FIG. 23 is an explanatory diagram showing a specific example of the screen definition information for the second screen. FIG. 24 is an explanatory diagram (part 1) showing an example of normalization processing of the second screen. FIG. 25 is an explanatory diagram (part 2) showing an example of the normalization process of the second screen. FIG. 26 is an explanatory diagram (part 3) showing an example of the normalization process of the second screen. FIG. 27 is an explanatory diagram (part 4) showing an example of the normalization process of the second screen. FIG. 28 is an explanatory diagram (part 5) showing an example of the normalization process of the second screen. FIG. 29 is an explanatory diagram (part 6) showing an example of the normalization process of the second screen. FIG. 30 is an explanatory diagram showing an example of an output screen. FIG. 31 is a flowchart showing an example of a verification process procedure of the information processing device 101. FIG. 32 is a flowchart illustrating an example of a specific processing procedure of the file analysis process. FIG. 33 is a flowchart illustrating an example of a specific processing procedure of the element normalization process. FIG. 34 is a flowchart illustrating an example of a specific processing procedure for creating an element name list. FIG. 35 is a flowchart illustrating an example of a specific processing procedure for creating a regular element table. FIG. 36 is a flowchart illustrating an example of a specific processing procedure for element division processing. FIG. 37 is a flowchart showing an example of a specific processing procedure for creating a regular element table and an element table. FIG. 38 is a flowchart illustrating an example of a specific procedure for the space insertion process. FIG. 39 is a flowchart illustrating an example of a specific processing procedure for the configuration information output process.

Below, embodiments of the verification program, verification method, and information processing device according to the present invention will be described in detail with reference to the drawings.

(Embodiment)
Fig. 1 is an explanatory diagram showing an example of a verification method according to an embodiment. In Fig. 1, an information processing device 101 is a computer that supports verification of a screen configuration accompanying a system migration. The information processing device 101 is, for example, a PC (Personal Computer) or a tablet PC. The information processing device 101 may also be a server.

Now, application software (hereafter referred to as "apps") available in the world are often constructed around a GUI (Graphical User Interface), with an emphasis on making information easy for non-technical users to view and easy to learn how to operate.

To create an application with a GUI, a definition that represents the screen layout, typically in HTML (Hypertext Markup Language), is required. Screen definitions that represent the screen layout can be files written in languages such as HTML, or they can be binary files.

In recent years, with the opening up of systems and support for smart devices, there has been active migration of GUI applications, and there are an increasing number of cases where screen definitions are migrated to a different format. If the screen definitions before and after the migration satisfy, for example, the following requirements (i) and (ii), then the screens can be said to have the same functions.

Requirement (i): There are no omissions in the screen components before and after the transition. Requirement (ii): There is no change in the positional relationship of the screen components before and after the transition.

If requirement (i) is not met, the app may not function correctly. Furthermore, if requirement (ii) is not met, the relative positions of the components may change, which may change the user's operational experience and cause a burden on the user. For this reason, when migrating a GUI app, a verification process is required to check these requirements and determine whether there are any errors in the screen configuration.

Conventional verification methods, for example, involve workers visually comparing screens before and after migration to determine whether there are any errors. However, when verification is performed by visual comparison, if there are a large number of screens to be verified, not only will some screens be missed, but there are also problems with the time and workload required for the verification work increasing. In addition, differences in operating environments (for example, between an office computer system and an open system) can make it difficult to display the screens before and after migration side by side.

Another conventional verification method is to use screen capture. In this verification method, for example, the pre-migration screen is image-analyzed to mechanically capture the screen configuration, and based on that data, it is determined whether it matches the post-migration screen. However, because this verification method is based on the premise that the pre-migration and post-migration screens are completely compatible, it will judge differences in screen format (for example, differences in the shape of input fields) as errors.

For example, when comparing screens using screen captures, screens with the same screen configuration are judged to be different screens due to differences in the specific expressions in the files that define the screens and the exact positions of the components. In other words, because the shapes and positions of the components are strictly judged, it is not possible to verify only the omissions and positional relationships of the components, which is what you would originally want to do.

In this embodiment, therefore, a verification method is described that extracts only the elements that make up the screen from the information that defines the screen configuration, and normalizes the elements according to a predetermined rule, thereby making it easy to verify the above requirements (i) and (ii), thereby reducing the workload and work time required for verifying the screen configuration. Here, an example of the processing of the information processing device 101 is described.

(1) The information processing device 101 extracts information about a plurality of elements constituting the screen from the screen definition file for each of the first screen of the first system and the second screen of the second system to which the first system is migrated. Here, the screen definition file is information that defines the configuration of the screen, and is, for example, an HTML file or a binary file.

The first system is the system before migration, for example a system built with COBOL on an office computer. The second system is the system after migration to which the first system is migrated, for example an open system. The second screen of the second system is a screen that corresponds to the first screen of the first system, for example a screen that is required to have the same functions as the first screen of the first system.

The multiple elements include, for example, elements that represent at least one of an input item, an output item, a literal (constant), a button, and an image. The multiple elements may also include an element that represents a space. Information about an element indicates, for example, the position, size, type, value, etc. of the element.

In the example of FIG. 1, the screen definition file for the first screen is the "screen definition file 110 of format A," and the screen definition file for the second screen is the "screen definition file 120 of format B." In this case, the information processing device 101 extracts information about the multiple elements that make up the first screen from the screen definition file 110 of format A. Also, the information processing device 101 extracts information about the multiple elements that make up the second screen from the screen definition file 120 of format B.

(2) The information processing device 101 performs normalization processing for each of the first screen and the second screen based on the information about the extracted multiple elements. Here, the normalization processing is processing that makes it possible to distinguish the type of each of the multiple elements, the element name of each of the multiple elements, and the relative positional relationship between the multiple elements according to predetermined normalization rules, and eliminates differences in the display shape and size between the screens of each of the multiple elements.

The type is information that classifies an element. The element name is information that uniquely identifies an element on the screen. Furthermore, making it possible to distinguish the relative positional relationships between elements does not mean making it possible to distinguish the strict positions of elements on the screen, but rather, for example, making it possible to distinguish where one element on the screen is located in relation to other elements.

Furthermore, excluding differences in the display shape of an element between screens means that even if there is a difference in the shape of an element between screens, such as between a rectangle and an oval, or a square and a circle, this difference is not judged as a difference in the element. Furthermore, excluding differences in the display size of an element between screens means that, for example, even if there is a difference in the vertical and horizontal size of an element of a certain shape between screens, this difference is not judged as a difference in the element.

Specifically, for example, the information processing device 101 creates screen configuration information for each of the first screen and the second screen based on information about the extracted multiple elements. The screen configuration information is, for example, information having character strings representing element names including types, separated by commas, and indicates which types of elements appear in what order.

To explain in more detail, for example, the information processing device 101 creates screen configuration information by listing element names including the types of elements that appear in the column direction in each area that is divided by dividing the screen row-wise based on the vertical position and vertical size of each of the multiple elements. However, when the area switches row-wise, the information processing device 101 inserts an element name including a type that indicates a line break.

If the element type is other than a newline or a space, the element name includes an identification number that indicates the order in which elements of that type appear on the screen (the order in which the elements were declared on the screen). In other words, if the element type is other than a newline or a space, the element name will be, for example, "type - identification number." Note that the row direction corresponds to the top-to-bottom direction of the screen. The column direction corresponds to the left-to-right direction of the screen.

For example, the information processing device 101 may also create screen configuration information by listing element names including the types of elements that appear in the row direction in each area that is divided into columns based on the horizontal positions and horizontal sizes of each of a plurality of elements. However, when the area switches to the column direction, the information processing device 101 inserts an element name including a type that indicates a line break.

In the example of FIG. 1, it is assumed that screen configuration information 111 (from format A) is created as a result of normalization processing being performed based on information about multiple elements extracted from a screen definition file 110 of format A. It is also assumed that screen configuration information 121 (from format B) is created as a result of normalization processing being performed based on information about multiple elements extracted from a screen definition file 120 of format B.

(3) The information processing device 101 outputs the results of the normalization process performed on each of the first screen and the second screen. By comparing the results of the normalization process for each screen, it is possible to verify whether there are any omissions or changes in the positional relationship of the elements that make up the screen between the first screen and the second screen.

In the example of FIG. 1, screen configuration information 111 (from format A) and screen configuration information 121 (from format B) are output in association with each other.

In this way, the information processing device 101 can provide information that can be used to verify that there are no omissions in the screen components before and after the migration, and that there is no change in the positional relationship of the screen components before and after the migration. This makes it easy to verify the screen configuration following a system migration.

In the example of FIG. 1, by comparing screen configuration information 111 (from format A) with screen configuration information 121 (from format B), it is possible to verify whether there are any errors in the screen configuration between the first screen and the second screen. The comparison of screen configuration information is performed, for example, by a simple string comparison.

For example, if screen configuration information 111 and screen configuration information 121 match, it can be seen that there are no missing components and no change in the positional relationship of the components between the first screen and the second screen. On the other hand, if screen configuration information 111 and screen configuration information 121 do not match, it can be seen that there is a missing component or a change in the positional relationship of the components between the first screen and the second screen.

The process of comparing the screen configuration information 111 and 121 may be executed in the information processing device 101, or may be executed on another computer different from the information processing device 101.

(Example of hardware configuration of information processing device 101)
Fig. 2 is a block diagram showing an example of a hardware configuration of the information processing device 101. In Fig. 2, the information processing device 101 has a CPU (Central Processing Unit) 201, a memory 202, a disk drive 203, a disk 204, a communication I/F (Interface) 205, a display 206, an input device 207, a portable recording medium I/F 208, and a portable recording medium 209. In addition, each component is connected to each other by a bus 200.

Here, the CPU 201 is responsible for the overall control of the information processing device 101. The CPU 201 may have multiple cores. The memory 202 includes, for example, a ROM (Read Only Memory), a RAM (Random Access Memory), and a flash ROM. Specifically, for example, the flash ROM stores an OS (Operating System) program, the ROM stores application programs, and the RAM is used as a work area for the CPU 201. The programs stored in the memory 202 are loaded into the CPU 201 to cause the CPU 201 to execute the coded processes.

The disk drive 203 controls the reading/writing of data from/to the disk 204 under the control of the CPU 201. The disk 204 stores data written under the control of the disk drive 203. Examples of the disk 204 include a magnetic disk and an optical disk.

The communication I/F 205 is connected to the network 210 through a communication line, and is connected to an external computer via the network 210. The communication I/F 205 serves as an interface between the network 210 and the inside of the device, and controls the input and output of data from the external computer. The network 210 is, for example, the Internet, a LAN, or a WAN (Wide Area Network). For example, a modem or a LAN adapter can be used as the communication I/F 205.

The display 206 is a display device that displays data such as a cursor, an icon, a tool box, documents, images, and function information. For example, a liquid crystal display or an organic EL (Electroluminescence) display can be used as the display 206.

The input device 207 has keys for inputting letters, numbers, various instructions, etc., and is used to input data. The input device 207 may be a keyboard or a mouse, or may be a touch panel input pad or numeric keypad.

The portable recording medium I/F 208 controls the reading/writing of data from/to the portable recording medium 209 under the control of the CPU 201. The portable recording medium 209 stores data written under the control of the portable recording medium I/F 208. Examples of the portable recording medium 209 include a CD (Compact Disc)-ROM, a DVD (Digital Versatile Disk), and a USB (Universal Serial Bus) memory.

Note that the information processing device 101 may not have any of the above-mentioned components, such as the disk drive 203, the disk 204, the portable recording medium I/F 208, and the portable recording medium 209.

(Example of functional configuration of information processing device 101)
3 is a block diagram showing an example of a functional configuration of the information processing device 101. In FIG. 3, the information processing device 101 includes an acquisition unit 301, an extraction unit 302, a normalization unit 303, a comparison unit 304, and an output unit 305. The acquisition unit 301 to the output unit 305 are functions that become a control unit, and specifically, the functions are realized by causing the CPU 201 to execute a program stored in a storage device such as the memory 202, the disk 204, or the portable recording medium 209 shown in FIG. 2, or by the communication I/F 205. The processing results of each functional unit are stored in a storage device such as the memory 202 or the disk 204.

The acquisition unit 301 acquires a first screen definition file that defines the configuration of the first screen of the first system, and a second screen definition file that defines the configuration of the second screen of the second system. Here, the first system is the system before migration. The second system is the system after migration to which the first system is migrated. The second screen of the second system is a screen that corresponds to the first screen of the first system, and is, for example, a screen that is required to have the same functions as the first screen of the first system.

In the following explanation, either the first screen definition file that defines the configuration of the first screen or the second screen definition file that defines the configuration of the second screen may be referred to simply as the "screen definition file."

A screen definition file is information that represents a screen definition. The first screen definition file and the second screen definition file are, for example, screen definition files with different formats. For example, the first screen definition file is a binary file in a company-specific format. And the second screen definition file is, for example, an HTML file.

Specifically, for example, the acquisition unit 301 acquires the first screen definition file and the second screen definition file by a user's operational input using the input device 207 shown in Fig. 2. The acquisition unit 301 may also acquire the first screen definition file and the second screen definition file by receiving them from another computer via the network 210 shown in Fig. 2.

Here, we will explain the screen images of the first and second screens.

Figure 4 is an explanatory diagram showing a screen image of the first screen. In Figure 4, the first screen 400 is the screen of the first system, and includes items 401 to 407. Item 401 is one of the elements that make up the first screen 400, and indicates a constant. Item 402 is one of the elements that make up the first screen 400, and indicates an input item.

Item 403 is one of the elements that make up the first screen 400 and indicates a constant. Item 404 is one of the elements that make up the first screen 400 and indicates an output item. Item 405 is one of the elements that make up the first screen 400 and indicates a constant. Item 406 is one of the elements that make up the first screen 400 and indicates a button. Item 407 is one of the elements that make up the first screen 400 and indicates a button.

The format of the screen definition file that defines the configuration of the first screen 400 is a format in which the position of an item is specified by row and column (row: vertical, column: horizontal) at regular intervals. The size of an item is specified by row and column. For example, the position of item 401 is specified as "row: 2, column: 3". The screen definition file that defines the configuration of the first screen 400 is, for example, a binary file (not shown).

Figure 5 is an explanatory diagram showing a screen image of the second screen. In Figure 5, the second screen 500 is a screen of the second system, and includes items 501 to 507. Item 501 is one of the elements that make up the second screen 500, and indicates a constant. Item 502 is one of the elements that make up the second screen 500, and indicates an input item.

Item 503 is one of the elements that make up the second screen 500 and indicates a constant. Item 504 is one of the elements that make up the second screen 500 and indicates an output item. Item 505 is one of the elements that make up the second screen 500 and indicates a constant. Item 506 is one of the elements that make up the second screen 500 and indicates a button. Item 507 is one of the elements that make up the second screen 500 and indicates a button.

The format of the screen definition file that defines the configuration of the second screen 500 is HTML format, which specifies the position of an item by its vertical position (number of pixels) and horizontal position (number of pixels). The vertical height of an item is specified by the font size. For example, the position of item 501 is specified as "vertical position (px): 10, horizontal position (px): 50". However, because HTML fills in the gaps between items and elements such as buttons with spaces and borders, the declared position may differ from the actual displayed position.

The screen definition file that defines the configuration of the second screen 500 is, for example, an HTML file 600 as shown in FIG. 6.

Figure 6 is an explanatory diagram showing a specific example of an HTML file. In Figure 6, HTML file 600 is an example of a screen definition file that defines the configuration of second screen 500 shown in Figure 5. Note that the area of second screen 500 declared in HTML is an area of 190px x 310px (frame line 510 in Figure 5).

Returning to the explanation of FIG. 3, the extraction unit 302 extracts information about the multiple elements that make up the screen for each of the first screen of the first system and the second screen of the second system from a screen definition file that defines the configuration of the screen. Here, the multiple elements include, for example, elements that represent at least one of an input item, an output item, a fixed literal (constant), a button, and an image. The multiple elements may also include an element that represents a blank space.

The information about an element indicates, for example, the position, size, type, and value of the element. The position of an element is the position of the element on the screen, and is represented, for example, by the coordinates of the top left corner of the element. The size of an element is represented, for example, by the vertical and horizontal sizes of the element. Examples of element types include input items, output items, fixed literals (constants), buttons, and images. The value of an element is, for example, an initial value. The information about an element also includes information that specifies the size of the screen. The size of the screen is represented, for example, by the number of rows and columns, or by the number of vertical and horizontal pixels.

Specifically, for example, the extraction unit 302 creates screen definition information for each screen based on the screen definition file of each screen. The screen definition information is information necessary for element normalization, and includes information about the elements extracted from the screen definition file. Here, the data structure of the screen definition information is described with reference to FIG. 7.

Figure 7 is an explanatory diagram showing an example of the data structure of screen definition information. In Figure 7, the screen definition information sd includes a screen size and an element table. The element table stores the position, size, item type, and value for each element. A specific example of the screen definition information sd will be described later using, for example, Figure 16.

The normalization unit 303 performs normalization processing for each of the first screen and the second screen based on the information about the extracted multiple elements. Here, the normalization processing is processing that makes it possible to distinguish the type of each of the multiple elements, the element name of each of the multiple elements, and the relative positional relationship between the multiple elements according to predetermined normalization rules, and eliminates differences in the display shape and size (size) of each of the multiple elements between the screens.

The normalization unit 303 may further perform a normalization process that makes it possible to distinguish the relative magnitude relationships between multiple elements. The normalization unit 303 may also perform a normalization process that makes it possible to distinguish the values of multiple elements. The element values are, for example, initial values, item names, button names, etc.

Specifically, for example, the normalization unit 303 creates screen configuration information by listing element names including the type of element that appears in the column direction in each area that is divided into rows based on the vertical position and vertical size of each of the multiple elements. However, when the area switches to the row direction, the normalization unit 303 inserts an element name including a type that indicates a line break. If the element type is other than a line break or space, the element name includes an identification number that indicates the order in which elements of that type appear on the screen (the order in which the elements were declared on the screen).

The normalization unit 303 may also create screen configuration information by, for example, listing element names including the types of elements that appear in the row direction in each area that is divided into regions by dividing the screen in the column direction based on the horizontal position and horizontal size of each of the multiple elements. However, when the area switches to the column direction, the normalization unit 303 inserts an element name including a type that indicates a line break.

To explain in more detail, for example, the normalization unit 303 normalizes the screen definition information and creates a normalized element table. The normalized element table stores information about the normalized elements. On a typical screen, the position and size of each element can be freely specified, so it is not possible to express row and column units. In other words, because elements have different sizes and their positions can be freely set, dividing them into units results in the elements being separated.

The normalization unit 303 therefore breaks down the screen into rows (or columns) with an arbitrary row width (or column width) based on the screen definition information-element table, in accordance with the position and size of the elements, and creates a normalized element table. The screen definition information-element table indicates the element table included in the screen definition information. The normalization unit 303 then analyzes each row of the screen and creates a normalized element table.

Let us assume that a normalization rule is used that extracts elements (components) in the row and column direction, with the top left corner of the screen as the apex. In this case, the data structure of the normalized element table will be, for example, as shown in Figure 8. The structure of the normalized element table will differ depending on the normalization rule.

Fig. 8 is an explanatory diagram showing an example of the data structure of a regular element table. In Fig. 8, the regular element table nt includes a vertical position, a row width, and an element table. The element table stores the position (horizontal), size (horizontal), and element name of an element. Information about elements considered to be in the same row is stored in the same element table. There is no vertical information about the position and size in the element table, as this information is included in the start position and row width. A specific example of the regular element table nt will be described later, for example, using Fig. 13.

To explain in more detail, for example, the normalization unit 303 refers to the screen definition information-element table and sets the line width in the regular element table. The normalization unit 303 refers to the screen definition information-element table, splits elements that span multiple lines, and adds them to the screen definition information-element table. The normalization unit 303 rearranges the screen definition information-element table in row and column order. The normalization unit 303 refers to the screen definition information-element table and sets a regular element table-element table. The regular element table-element table indicates the element tables included in the regular element table. The normalization unit 303 also defines blank areas in places where nothing is defined in the regular element table.

Here, an example of normalization processing is explained using Figures 9 to 13.

Figures 9 to 13 are explanatory diagrams showing an example of normalization processing. In Figure 9, the normalization unit 303 references the screen definition information-element table and sets the line width in the normalized element table. Specifically, for example, the normalization unit 303 calculates the line width of the screen from the position (vertical) and size (vertical) of the referenced screen definition information-element table, and sets the vertical position and line width in the normalized element table.

At this time, the normalization unit 303 considers elements declared to have the same position (vertical) and size (vertical) to be on the same line. For example, in the case of screen 901, elements 1 and 2 are considered to be on different lines because their positions (vertical) are different. Also, in the case of screen 902, elements 1 and 2 are considered to be on the same line because their positions (vertical) and sizes (vertical) are the same. Also, when elements overlap vertically, as in screens 903 to 905, the normalization unit 303 considers the top and bottom of the elements to be line separators. In this case, element 2 in each of screens 903 to 905 spans multiple lines.

In FIG. 10, screen 1001 is taken as an example, and the screen definition information of screen 1001 is taken as screen definition information 1010. Screen definition information 1010 includes the screen size of screen 1001, "90 vertical x 200 horizontal," and an element table 1011. Element table 1011 stores the position, size, item type, and value for each of elements 1 and 2 that make up screen 1001.

Specifically, the first record in element table 1011 indicates the position, size, item type, and value of element 1. The position of element 1 (top left coordinates) is "vertical: 10, horizontal: 10". The size of element 1 is "vertical: 30, horizontal: 80". The item type of element 1 is "fixed literal". The value of element 1 is "element 1". The second record in element table 1011 indicates the position, size, item type, and value of element 2.

In this case, screen 1001 is divided into four rows at vertical positions 10, 40, and 60, and the row width of each row is set in regular element table 1020. Here, row widths of 10, 30, 20, and 30 are set in regular element table 1020. Also, the element tables of each row are denoted as tables A, B, C, and D from top to bottom.

In FIG. 11, the normalization unit 303 refers to the screen definition information 1010-element table 1011, splits elements that span multiple lines, and adds them to the screen definition information 1010-element table 1011. In other words, when elements overlap vertically, one element spans multiple lines, so the normalization unit 303 splits such elements on the screen definition information 1010-element table 1011. This makes it possible to distinguish the relative size relationships between multiple elements.

Here, element 2 on screen 1001 is split into two, and the record for element 2 (the second record) on screen definition information 1010-element table 1011 is split into two. As a result, the first record in element table 1011 indicates the position, size, item type, and value of element 1. In addition, the second and third records in element table 1011 indicate the position, size, item type, and value of element 2.

The normalization unit 303 also rearranges the screen definition information 1010-element table 1011 in row and column order. That is, the normalization unit 303 rearranges the records in row and column order because the records in the screen definition information 1010-element table 1011 may not be in row and column order due to the division of the elements.

Specifically, for example, the normalization unit 303 sorts the records of the screen definition information 1010-element table 1011 in ascending order of vertical position, and then in ascending order of horizontal position. In the example of FIG. 11, the records of the screen definition information 1010-element table 1011 are not rearranged.

In FIG. 12, the normalization unit 303 sets the normalized element table 1020-element table by referencing the screen definition information 1010-element table 1011. Specifically, for example, the normalization unit 303 refers to the position (vertical) of the screen definition information 1010-element table 1011 and the vertical position of the normalized element table 1020, and sets the information of the screen definition information 1010-element table 1011 in the element table of the corresponding row.

At this time, the normalization unit 303 sets the element name of the normalized element table 1020-element table using, for example, the item type. The element name is expressed in the form "item type-identification number" which combines the item type and the identification number. The identification number is assigned as a consecutive four-digit number for each item type in the order declared in the row and column direction, starting from the top left corner of the screen. However, if the item type is a space or a line break, no identification number is assigned.

Here, the vertical position "10" in the screen definition information 1010-element table 1011 corresponds to the regular element table 1020-element table B. Therefore, the normalization unit 303 sets information in the regular element table 1020-element table B based on the first and second records in the screen definition information 1010-element table 1011.

Specifically, for example, the normalization unit 303 sets "Position (horizontal): 10", "Size (horizontal): 80", and "Element name: Literal-0001" in the normalized element table 1020 - element table B based on the first record in the screen definition information 1010 - element table 1011. Literal-0001 indicates that it is the first fixed literal (constant) declared in the row and column direction with the top left corner of the screen as the apex.

The normalization unit 303 also sets "Position (horizontal): 100", "Size (horizontal): 80", and "Element name: Literal-0002" in the normalized element table 1020-element table B based on the second record in the screen definition information 1010-element table 1011. Literal-0002 indicates that it is the second fixed literal (constant) declared in the row and column direction with the top left corner of the screen as the apex.

The vertical position "40" in the screen definition information 1010-element table 1011 corresponds to the regular element table 1020-element table C. Therefore, the normalization unit 303 sets "Position (horizontal): 100", "Size (horizontal): 80", and "Element name: Literal-0002" in the regular element table 1020-element table C based on the third record in the screen definition information 1010-element table 1011.

In addition to Literal, strings that indicate item types include Space, NewLine, Input, Output, Button, Media, and Other. Space indicates a blank space (an area where no items are defined). NewLine indicates a line break. Input indicates an input item. Output indicates an output item. Button indicates a button. Media indicates an image. Other indicates other items such as elements specific to the screen definition file. Parameters such as values, data names, and item sizes may be added using normalization rules.

In FIG. 13, the normalization unit 303 defines blank areas in places where nothing is defined in the normalized element table 1020. Specifically, for example, the normalization unit 303 refers to the normalized element table 1020 - the position (horizontal) and size (horizontal) of the element table, and if there is an area where nothing is defined, it adds an item (record) with the element name: Space.

For example, element table B has no definition for "Position (horizontal): 0" or "Size (horizontal): 10". In other words, nothing is defined for "Position (horizontal): 0-10" of "Vertical position: 0" on screen 1001. Therefore, the normalization unit 303 adds records for "Position (horizontal): 0", "Size (horizontal): 10", and "Element name: Space" to normalized element table 1020-element table B.

Furthermore, in element table B, nothing is defined for "Position (horizontal): 90" and "Size (horizontal): 10". In other words, nothing is defined between element 1 and element 2 at "Vertical position: 0" on screen 1001. Therefore, the normalization unit 303 adds records for "Position (horizontal): 90", "Size (horizontal): 10", and "Element name: Space" to normalized element table 1020 - element table B.

Furthermore, in element table B, nothing is defined for "Position (horizontal): 180" and "Size (horizontal): 20". In other words, nothing is defined for "Position (horizontal): 180-200" of "Vertical position: 0" on screen 1001. Therefore, the normalization unit 303 adds records for "Position (horizontal): 180", "Size (horizontal): 20", and "Element name: Space" to normalized element table 1020-element table B.

The same is true for regular element table 1020 - element table C.

Also, when there is no element in the regular element table 1020-element table, the row is blank. In this case, the size (width) of the blank space is the width of the screen 1001, "200". For example, nothing is defined in the regular element table 1020-element table A. Therefore, the normalization unit 303 adds records of "Position (width): 0", "Size (width): 200", and "Element name: Space" to the regular element table 1020-element table A.

The same is true for regular element table 1020 - element table D.

The normalization unit 303 also outputs the results of the normalization process performed on each of the first and second screens. Specifically, for example, the normalization unit 303 symbolizes the created normalized element table and outputs screen configuration information. The screen configuration information is information that contains only character strings representing element names, separated by commas.

To explain in more detail, for example, the normalization unit 303 outputs the screen configuration information by referring to the normalized element table-element table in order and listing the element names. At this time, when the normalization unit 303 reads the element table next to the normalized element table, it outputs the element name "NewLine", which means a line break.

The screen configuration information indicates what type of elements appear and in what order when elements are scanned row-by-row, starting from the top left corner of the screen. By comparing the screen configuration information between the screens before and after the transition, the requirements for checking the screen before and after the transition (number of elements, positional relationships) can be met without being affected by differences in expression or strict positional relationships.

Here, we will use Figure 14 to explain an example of screen configuration information output.

Figure 14 is an explanatory diagram showing an example of screen configuration information output. In Figure 14, the normalization unit 303 lists element names by referring to the normalized element table 1020 - element tables A, B, C, and D in order. At this time, when the normalization unit 303 reads the next element table, it outputs the element name "NewLine", which means a line break.

Specifically, for example, the normalization unit 303 first references the normalized element table 1020-element table A and outputs the element name "Space". Next, the normalization unit 303 reads the normalized element table 1020-element table B, and outputs the element name "NewLine" separated by a comma.

Then, the normalization unit 303 references the normalized element table 1020-element table B, and outputs each element name from top to bottom, separated by commas. In this case, the element names "Space, Literal-0001, Space, Literal-0002, Space" are output. Next, the normalization unit 303 reads the normalized element table 1020-element table C, and outputs the element name "NewLine", separated by commas.

Then, the normalization unit 303 references the normalized element table 1020-element table C, and outputs each element name from top to bottom, separated by commas. In this case, the element names "Space, Literal-002, Space" are output. Next, the normalization unit 303 reads the normalized element table 1020-element table D, and outputs the element name "NewLine", separated by commas.

Then, the normalization unit 303 references the normalized element table 1020-element table D, and outputs the element name "Space", separated by a comma. As a result, the screen configuration information 1400 is created. According to the screen configuration information 1400, it is possible to determine which types of elements appear and in what order when elements are scanned in the row and column direction from the top left corner of the screen 1001 (see FIG. 10, for example).

In the above explanation, an example was given of a case where a normalization rule is used that extracts elements in the row and column direction with the top left corner of the screen as the apex, but this is not limited to this. For example, as shown in FIG. 15, other normalization rules may be used as long as they satisfy the requirements for verification (no elements are missing and positional relationships are maintained).

Figure 15 is an explanatory diagram showing an example of another normalization rule. As shown in (15-1) of Figure 15, the normalization unit 303 may use a normalization rule that extracts elements (components) in the row direction, with the top left corner of the screen as the apex, for example.

Also, as shown in (15-2), the normalization unit 303 may extract elements while ignoring spaces between elements. In this case, taking the normalized element table 1020-element table B shown in FIG. 13 as an example, for example, the third record will be missing, and the position (horizontal) and size (horizontal) of the fourth record will be "position (horizontal): 90" and "size (horizontal): 90".

Also, as shown in (15-3), the normalization unit 303 may extract elements without dividing them. That is, the normalization unit 303 executes normalization processing that does not distinguish between relative magnitude relationships between elements. In this case, taking the normalized element table 1020 shown in FIG. 10 as an example, for example, to match the size of element 2, the line width of the second record will be "50", and the vertical position of the third record will be "60" and the line width will be "30". Also, the fourth record will disappear.

Returning to the explanation of FIG. 3, the comparison unit 304 compares the results of the normalization process performed on each of the first and second screens. Specifically, for example, the comparison unit 304 compares the screen configuration information of each of the first and second screens. The comparison of the screen configuration information is performed, for example, by a simple string comparison.

If the screen configuration information matches, then the screen configuration is the same before and after the transition, meaning that there are no missing screen components before and after the transition, and there is no change in the relative positions of the screen components before and after the transition. On the other hand, if the screen configuration information does not match, then the screen configuration is different before and after the transition, meaning that there are missing screen components or changes in the relative positions of the screen components before and after the transition.

In addition, if the screen configuration information of the first screen and the second screen match, the comparison unit 304 may determine that there is no error in the screen configuration after the transition (verification OK). On the other hand, if the screen configuration information of the first screen and the second screen do not match, the comparison unit 304 may determine that there is an error in the screen configuration after the transition (verification NG).

The output unit 305 outputs the results of the comparison. The output format of the output unit 305 may be, for example, storage in a storage device such as the memory 202 or the disk 204, transmission to another computer via the communication I/F 205, display on the display 306, or printout on a printer (not shown).

Specifically, for example, the output unit 305 may display on the display 206 information indicating whether or not the screen configuration information of the first screen and the second screen matches. The output unit 305 may also display on the display 206 a determination result indicating whether or not there is an error in the screen configuration after the transition.

The output unit 305 may also output the results of the normalization process performed on each of the first screen and the second screen. Specifically, for example, the output unit 305 may output the screen configuration information of each of the first screen and the second screen in association with each other. This allows, for example, a process of comparing the screen configuration information of each of the first screen and the second screen to be performed on a computer other than the information processing device 101.

The information processing device 101 may perform multi-perspective verification using, for example, multiple normalization rules. For example, if the screen definitions are highly compatible, the verification accuracy can be improved by gradually strengthening the normalization rules. Specifically, for example, the information processing device 101 performs verification using normalization rules that extract elements that do not contain spaces as a first step. In the first step, the number and positional relationship of the defined components can be verified. In addition, the information processing device 101 performs verification using normalization rules that extract elements that contain spaces as a second step. In the second step, the positional relationship between the defined elements can be verified. In addition, the information processing device 101 performs verification using normalization rules that include elements unique to the screen definition file as a third step. In the third step, for example, strict element verification can be performed.

Furthermore, among the functional units of the information processing device 101 described above, for example, the comparison unit 304 may be realized by another computer different from the information processing device 101. In other words, the process of comparing the results of the normalization process performed on each of the first screen and the second screen may be executed by another computer. In this case, the information processing device 101 outputs the results of the normalization process performed on each of the first screen and the second screen, for example, by the output unit 305.

(Screen configuration verification example)
Next, an example of verifying the screen configuration before and after the transition will be described using the first screen 400 shown in FIG. 4 and the second screen 500 shown in FIG. 5 as examples.

First, the process for creating the screen configuration information for the first screen 400 will be explained using Figures 16 to 22.

Figure 16 is an explanatory diagram showing a specific example of screen definition information for the first screen. Also, Figures 17 to 22 are explanatory diagrams showing examples of normalization processing for the first screen. The extraction unit 302 creates screen definition information sd1 based on the screen definition file of the first screen 400.

In FIG. 16, the screen definition information sd1 includes the screen size of the first screen 400, "9 rows x 14 columns," and an element table 1600. The element table 1600 stores the position, size, item type, and value of each element that constitutes the first screen 400.

The extraction unit 302 sorts the element table 1600 of the screen definition information sd1 in row and column order. In this case, the element table 1600 is originally arranged in row and column order, so no rearrangement occurs.

In FIG. 17, the normalization unit 303 sets the line width in the normalized element table nt1 by referring to the screen definition information sd1-element table 1600. Here, in the screen definition information sd1-element table 1600, elements (items) are declared at regular intervals between rows, so the line width in the normalized element table nt1 is set in single-digit intervals.

In addition, in the screen definition information sd1-element table 1600, there are no elements that span multiple lines, so no element splitting occurs, and no rearrangement of the element table 1600 occurs.

In FIG. 18, the normalization unit 303 references the position (row) of the screen definition information sd1-element table 1600 and the vertical position of the normalized element table nt1, and sets the information of the screen definition information sd1-element table 1600 in the element table of the corresponding row.

For example, position (row) "2" in screen definition information sd1-element table 1600 corresponds to regular element table nt1-element table B. Therefore, the normalization unit 303 sets information in regular element table nt1-element table B based on the first and second records in screen definition information sd1-element table 1600.

In addition, position (row) "4" in the screen definition information sd1-element table 1600 corresponds to the regular element table nt1-element table D. Therefore, the normalization unit 303 sets information in the regular element table nt1-element table D based on the third and fourth records in the screen definition information sd1-element table 1600.

In addition, position (row) "6" in the screen definition information sd1-element table 1600 corresponds to the regular element table nt1-element table F. Therefore, the normalization unit 303 sets information in the regular element table nt1-element table F based on the fifth record in the screen definition information sd1-element table 1600.

In addition, position (row) "8" in the screen definition information sd1-element table 1600 corresponds to the regular element table nt1-element table H. Therefore, the normalization unit 303 sets information in the regular element table nt1-element table H based on the sixth and seventh records in the screen definition information sd1-element table 1600.

In FIG. 19, element tables B, D, F, and H of regular element table nt1 are shown. Taking element table B as an example, "horizontal position (digits): 3", "size (number of digits): 2", and "element name: Literal-0001" are set in regular element table nt1-element table B based on the first record in screen definition information sd1-element table 1600 (first record). Also, based on the second record in screen definition information sd1-element table 1600, "horizontal position (digits): 5", "size (number of digits): 8", and "element name: Input-0001" are set in regular element table nt1-element table B (second record).

In FIG. 20, the normalization unit 303 refers to the horizontal position (digits) and size (number of digits) of the normalized element table nt1-element table, and if there is an area where nothing is defined, it adds an item (record) with the element name: Space.

For example, nothing is defined in element table A. Therefore, the normalization unit 303 adds the records "Horizontal position (digits): 1", "Size (number of digits): 14", and "Element name: Space" to normalized element table nt1-element table A. Size (number of digits): 14 is the horizontal size of the first screen 400.

For example, element table B has no definition for "horizontal position (digits): 1" or "size (number of digits): 2". In other words, nothing is defined for "horizontal position (digits): 1-2" of "vertical position (row): 2" on the first screen 400. Therefore, the normalization unit 303 adds records for "horizontal position (digits): 1", "size (number of digits): 2" and "element name: Space" to normalized element table nt1-element table B.

In FIG. 21, regular element table nt1 - element tables A, B, C, D, E, F, G, H, and I are shown. Blank areas are defined in the places where nothing is defined in element tables A, B, C, D, E, F, G, H, and I.

In FIG. 22, the normalization unit 303 sequentially references the normalized element table nt1 and element tables A, B, C, D, E, F, G, H, and I, and lists the element names separated by commas to output the screen configuration information 2200. At this time, when the normalization unit 303 reads the element table next to the normalized element table nt1, it outputs the element name "NewLine", which means a line break.

The screen configuration information 2200 indicates which types of elements appear and in what order when elements are scanned in the row and column direction starting from the top left corner of the first screen 400.

Next, the process for creating the screen configuration information for the second screen 500 will be explained using Figures 23 to 29.

Figure 23 is an explanatory diagram showing a specific example of screen definition information for the second screen. Also, Figures 24 to 29 are explanatory diagrams showing examples of normalization processing for the second screen. The extraction unit 302 creates screen definition information sd2 based on the screen definition file for the second screen 500 (for example, the HTML file 600 shown in Figure 6).

In FIG. 23, the screen definition information sd2 includes the screen size of the second screen 500, "190px vertical x 310px horizontal," and an element table 2300. The screen size is calculated from the area declared from the top left. The element table 2300 stores the position, size, item type, and value of each element that constitutes the second screen 500.

The extraction unit 302 sorts the element table 2300 of the screen definition information sd2 in row and column order. In this case, the element table 2300 is originally arranged in row and column order, so no rearrangement occurs.

In FIG. 24, the normalization unit 303 sets the line width in the normalized element table nt2 by referring to the screen definition information sd2-element table 2300. Here, since the position of the element (item) is specified in the screen definition information sd2-element table 2300, the line width is set by referring to the vertical position. Note that FIG. 24 shows an image of lines dividing the second screen 500 in the column direction.

In addition, in the screen definition information sd2-element table 2300, there are no elements that span multiple lines, so no element splitting occurs, and no rearrangement of the element table 2300 occurs.

In FIG. 25, the normalization unit 303 references the position (row) of the screen definition information sd2-element table 2300 and the vertical position of the normalized element table nt2, and sets the information of the screen definition information sd2-element table 2300 in the element table of the corresponding row.

For example, the position (px) "vertical: 10" in the screen definition information sd2-element table 2300 corresponds to the regular element table nt2-element table B. Therefore, the normalization unit 303 sets information in the regular element table nt2-element table B based on the first and second records in the screen definition information sd2-element table 2300.

In addition, the position (px) "vertical: 50" of the screen definition information sd2-element table 2300 corresponds to the regular element table nt2-element table D. Therefore, the normalization unit 303 sets information in the regular element table nt2-element table D based on the third and fourth records of the screen definition information sd2-element table 2300.

In addition, the position (px) "vertical: 90" in the screen definition information sd2-element table 2300 corresponds to the regular element table nt2-element table F. Therefore, the normalization unit 303 sets information in the regular element table nt2-element table F based on the fifth record in the screen definition information sd2-element table 2300.

In addition, the position (px) "vertical: 145" of the screen definition information sd2-element table 2300 corresponds to the regular element table nt2-element table H. Therefore, the normalization unit 303 sets information in the regular element table nt2-element table H based on the sixth and seventh records of the screen definition information sd2-element table 2300.

In FIG. 26, element tables B, D, F, and H of regular element table nt2 are shown. Taking element table B as an example, "horizontal position (px): 50", "horizontal size (px): 40", and "element name: Literal-0001" are set in regular element table nt2-element table B based on the first record in screen definition information sd2-element table 2300 (first record). Also, based on the second record in screen definition information sd2-element table 2300, "horizontal position (px): 90", "horizontal size (px): 200", and "element name: Input-0001" are set in regular element table nt2-element table B (second record).

In FIG. 27, the normalization unit 303 refers to the horizontal position (px) and horizontal size (px) of the normalized element table nt2-element table, and if there is an area where nothing is defined, it adds an item (record) with the element name: Space.

For example, nothing is defined in element table A. Therefore, the normalization unit 303 adds records of "horizontal position (px): 0", "horizontal size (px): 310", and "element name: Space" to normalized element table nt2-element table A. Horizontal size (px): 310 is the horizontal size of the second screen 500.

For example, element table B has no definition for "horizontal position (px): 0" and "horizontal size (px): 50". In other words, nothing is defined for "horizontal position (px): 0-50" of "vertical position (px): 10" on the second screen 500. Therefore, the normalization unit 303 adds records for "horizontal position (px): 0", "horizontal size (px): 50", and "element name: Space" to normalized element table nt2-element table B.

In FIG. 28, the regular element table nt2 - element tables A, B, C, D, E, F, G, H, and I are shown. Blank areas are defined in the element tables A, B, C, D, E, F, G, H, and I where nothing is defined.

In FIG. 29, the normalization unit 303 sequentially references the normalized element table nt2 and element tables A, B, C, D, E, F, G, H, and I, and lists the element names separated by commas to output screen configuration information 2900. At this time, when the normalization unit 303 reads the element table next to the normalized element table nt2, it outputs the element name "NewLine", which means a line break.

(Example of output screen)
Next, a description will be given of an example of the output screen displayed on the display 206 shown in Fig. 2. The output screen is a screen for outputting the result of comparing the screen configuration information of the first screen and the second screen.

Figure 30 is an explanatory diagram showing an example of an output screen. In Figure 30, output screen 3000 shows the result of comparing screen configuration information 2200 of first screen 400 with screen configuration information 2900 of second screen 500. The comparison between screen configuration information 2200 and screen configuration information 2900 is performed by simple string comparison.

Here, message 3001 is displayed along with the comparison result "Match." Message 3001 is a message that indicates that the screen configuration is the same before and after the migration. In other words, it indicates that there are no missing components on the screen before and after the migration, and that there is no change in the relative positions of the screen components before and after the migration.

The output screen 3000 allows the user (verifier) to see that the screen configuration is the same before and after the transition and that there are no errors.

(Verification process procedure of information processing device 101)
Next, the verification process procedure of the information processing device 101 will be described.

Fig. 31 is a flowchart showing an example of a verification process procedure of the information processing device 101. In the flowchart of Fig. 31, first, the information processing device 101 executes a file analysis process for each of the first screen of the first system and the second screen of the second system (step S3101). The specific processing procedure of the file analysis process will be described later with reference to Fig. 32.

Next, the information processing device 101 executes an element normalization process for each of the first screen and the second screen (step S3102). The specific processing procedure of the element normalization process will be described later with reference to FIG. 33. Then, the information processing device 101 executes a configuration information output process for each of the first screen and the second screen (step S3103). The specific processing procedure of the configuration information output process will be described later with reference to FIG. 39.

Next, the information processing device 101 compares the screen configuration information of the first screen and the second screen (step S3104). The information processing device 101 then outputs the comparison result (step S3105) and ends the series of processes according to this flowchart.

This makes it possible to determine whether the post-transition screen configuration meets the requirements.

Next, the specific processing steps of the file analysis process in step S3101 shown in FIG. 31 will be described using FIG. 32.

Figure 32 is a flowchart showing an example of a specific processing procedure for file analysis processing. In the flowchart of Figure 32, first, the information processing device 101 reads a screen definition file (step S3201). Next, the information processing device 101 refers to the screen definition file and acquires screen size information (step S3202).

Then, the information processing device 101 sets the acquired screen size information in the screen definition information (step S3203). Next, the information processing device 101 refers to the screen definition file and reads one element that constitutes the screen (step S3204). Then, the information processing device 101 sets the information of the read element in the item corresponding to the element table of the screen definition information (step S3205).

Next, the information processing device 101 refers to the screen definition file and determines whether there are any unread elements (step S3206). If there are any unread elements (step S3206: Yes), the information processing device 101 returns to step S3204. On the other hand, if there are no unread elements (step S3206: No), the information processing device 101 returns to the step that called the file analysis process.

This allows the screen definition file to be analyzed and screen definition information sd to be generated.

Next, the specific processing steps of the element normalization process in step S3102 shown in FIG. 31 will be described using FIG. 33.

Figure 33 is a flowchart showing an example of a specific processing procedure for element normalization processing. In the flowchart of Figure 33, first, the information processing device 101 refers to the position (vertical) of the element table in the screen definition information and rearranges the elements in ascending order (step S3301). Next, the information processing device 101 refers to the position (vertical, horizontal) of the element table in the screen definition information and rearranges elements in the same vertical position in ascending order of horizontal position (step S3302).

Then, the information processing device 101 executes an element name list creation process (step S3303). The specific processing steps of the element name list creation process will be described later with reference to FIG. 34. Next, the information processing device 101 executes a regular element table creation process (step S3304). The specific processing steps of the regular element table creation process will be described later with reference to FIG. 35.

Then, the information processing device 101 executes element splitting processing (step S3305). A specific processing procedure of the element splitting processing will be described later with reference to FIG. 36. Next, the information processing device 101 refers to the position (vertical) of the element table in the screen definition information and rearranges it in ascending order (step S3306).

Then, the information processing device 101 refers to the element table positions (vertical, horizontal) of the screen definition information and rearranges elements in the same vertical position in ascending order of horizontal position (step S3307). Next, the information processing device 101 executes a regular element table-element table creation process (step S3308). The specific processing procedure of the regular element table-element table creation process will be described later with reference to FIG. 37.

The information processing device 101 then executes the space insertion process (step S3309) and returns to the step that called the element normalization process. The specific processing steps of the space insertion process will be described later with reference to FIG. 38.

This allows the elements that make up the screen to be normalized so that the screen composition can be verified.

Next, the specific processing steps of the element name list creation process in step S3303 shown in FIG. 33 will be described using FIG. 34.

Figure 34 is a flowchart showing an example of a specific processing procedure for the element name list creation process. In the flowchart of Figure 34, first, the information processing device 101 creates an element name list table having item types, values, and element names (step S3401). Next, the information processing device 101 refers to the top of the element table of the screen definition information (step S3402).

Then, the information processing device 101 determines whether the element name list table contains an item whose item type and element name are the same as those in the screen definition information-element table (step S3403). If the same item is found (step S3403: Yes), the information processing device 101 proceeds to step S3405.

On the other hand, if there is no identical item (step S3403: No), the information processing device 101 adds the item type "screen definition information-item type in element table", the value "screen definition information-value in element table", and the element name "(item type)-(identification number)" to the element name list table (step S3404). However, the identifier representing the item type is set in half-width English characters. The identification numbers are set so that they are consecutive numbers for the same (item type).

Then, the information processing device 101 determines whether or not there is a next screen definition information-element table (step S3405). If there is a next screen definition information-element table (step S3405: Yes), the information processing device 101 advances the screen definition information-element table by one (step S3406) and returns to step S3403.

On the other hand, if there is no next screen definition information-element table (step S3405: No), the information processing device 101 returns to the step where the element name list creation process was called.

This allows you to create a list of element names for the elements that make up the screen.

Next, the specific processing steps of the regular element table creation process in step S3304 shown in FIG. 33 will be described using FIG. 35.

Fig. 35 is a flowchart showing an example of a specific processing procedure for creating a regular element table. In the flowchart of Fig. 35, first, the information processing device 101 declares an array X that stores vertical positions (step S3501). Next, the information processing device 101 adds 0 to the array X (step S3502).

The information processing device 101 then adds the value of the screen size (vertical) of the screen definition information to array X (step S3503). The information processing device 101 then sequentially refers to the element table of the screen definition information and stores the vertical position value of each element in array X (step S3504). The information processing device 101 then sequentially refers to the element table of the screen definition information and stores the vertical position + size (vertical) value of each element in array X (step S3505).

Then, the information processing device 101 rearranges array X in ascending order (step S3506). Next, the information processing device 101 combines arrays in array X that have the same value into one (step S3507). Then, the information processing device 101 creates regular element tables (the number of arrays X - 1) in number (step S3508).

Then, the information processing device 101 refers to the beginning of array X and the regular element table (step S3509). Then, the information processing device 101 sets the vertical position "current value of array X" and the row width "next value of array X - current value of array X" in the regular element table (step S3510).

Next, the information processing device 101 determines whether or not there is a next regular element table (step S3511). If there is a next regular element table (step S3511: Yes), the information processing device 101 advances the reference position of the regular element table and array X by one (step S3512) and returns to step S3510.

On the other hand, if there is no next regular element table (step S3511: No), the information processing device 101 returns to the step that called the regular element table creation process.

This allows you to create the regular element table nt.

Next, the specific processing steps of the element splitting process in step S3305 shown in FIG. 33 will be described using FIG. 36.

Figure 36 is a flowchart showing an example of a specific processing procedure for element splitting processing. In the flowchart of Figure 36, first, the information processing device 101 refers to the beginning of the regular element table (step S3601). Next, the information processing device 101 refers to the beginning of the screen definition information-element table (step S3602).

Then, the information processing device 101 determines whether the vertical position of the referenced element is the same as the vertical position in the regular element table (step S3603). If the vertical position is different from the vertical position in the regular element table (step S3603: No), the information processing device 101 advances the regular element table by one (step S3604) and returns to step S3603.

On the other hand, if the vertical position of the referenced element is the same as that of the regular element table (step S3603: Yes), the information processing device 101 determines whether the vertical size of the referenced element is the same as the row width of the regular element table (step S3605). If the vertical size of the referenced element is the same as the row width of the regular element table (step S3605: Yes), the information processing device 101 proceeds to step S3607.

On the other hand, if it is different from the row width of the regular element table (step S3605: No), the information processing apparatus 101 splits the referenced screen definition information-element table (step S3606). However, the position of element 1 after splitting shall be "same as before splitting" vertically and "same as before splitting" horizontally. The size of element 1 after splitting shall be "row width of regular element table" vertically and "same as before splitting" horizontally. The item type of element 1 after splitting shall be "same as before splitting". The value of element 1 after splitting shall be "same as before splitting".

Furthermore, the position of element 2 after splitting shall be vertically "value before splitting + row width of regular element table" and horizontally "same as before splitting". The size of element 2 after splitting shall be vertically "value before splitting - row width of regular element table" and horizontally "same as before splitting". The item type of element 2 after splitting shall be "same as before splitting". The value of element 2 after splitting shall be "same as before splitting".

Then, the information processing device 101 determines whether or not there is a next screen definition information-element table (step S3607). If there is a next screen definition information-element table (step S3607: Yes), the information processing device 101 advances the screen definition information-element table by one (step S3608) and returns to step S3603.

On the other hand, if there is no next screen definition information-element table (step S3607: No), the information processing device 101 returns to the step that called the element splitting process.

This allows you to split elements that span multiple lines.

Next, the specific processing steps of the regular element table-element table creation process in step S3308 shown in FIG. 33 will be described using FIG. 37.

Figure 37 is a flowchart showing an example of a specific processing procedure for the regular element table-element table creation process. In the flowchart of Figure 37, the information processing device 101 first refers to the beginning of the regular element table (step S3701). Next, the information processing device 101 refers to the beginning of the screen definition information-element table (step S3702).

Then, the information processing device 101 determines whether the vertical position of the referenced element is the same as the vertical position in the regular element table (step S3703). If the vertical position is different from the vertical position in the regular element table (step S3703: No), the information processing device 101 advances the regular element table by one (step S3704) and returns to step S3703.

On the other hand, if the vertical position is the same as that of the regular element table (step S3703: Yes), the information processing device 101 sets the position (horizontal) "Screen definition information - element table position (horizontal)", size (horizontal) "Screen definition information - size (horizontal)", and element name "Element name of the table in the element name list that has the same value as the item type of the screen definition information - element table" in the element table of the regular element table (step S3705).

Then, the information processing device 101 determines whether or not there is a next screen definition information-element table (step S3706). If there is a next screen definition information-element table (step S3706: Yes), the information processing device 101 advances the screen definition information-element table by one (step S3707) and returns to step S3703.

On the other hand, if there is no next screen definition information-element table (step S3706: No), the information processing device 101 returns to the step that called the regular element table-element table creation process.

This allows you to create a regular element table nt-element table.

Next, the specific processing steps for the space insertion process in step S3309 shown in FIG. 33 will be described using FIG. 38.

Figure 38 is a flowchart showing an example of a specific processing procedure for space insertion processing. In the flowchart of Figure 38, first, the information processing device 101 reads the next regular element table (step S3801). Then, the information processing device 101 determines whether or not there is an element table in the read regular element table (step S3802).

If there is no element table (step S3802: No), the information processing device 101 adds position (horizontal) "0", size (horizontal) "screen definition information-screen size (horizontal)", and element name "Space" to the regular element table-element table (step S3803), and returns to step S3801.

On the other hand, if an element table is present (step S3802: Yes), the information processing device 101 sets the temporary variable Y, which stores the horizontal position, to 0 (step S3804). Then, the information processing device 101 reads the regular element table - element table (step S3805). Next, the information processing device 101 determines whether the position (horizontal) of the read element table is the same as the temporary variable Y (step S3806).

If it is different from the temporary variable Y (step S3806: No), the information processing device 101 adds an element with position (horizontal) "Y", size (horizontal) "Y-"screen definition information-position (horizontal)"" and element name "Space" next to the loaded element table (step S3807), and proceeds to step S3808.

On the other hand, if it is the same as the temporary variable Y (step S3806: Yes), the information processing device 101 sets the temporary variable Y that stores the horizontal position to the value of "Y = Position (horizontal) + Size (horizontal) of the loaded element table" (step S3808). Next, the information processing device 101 determines whether there is a regular element table - element table that has not been loaded (step S3809).

If a regular element table-element table is present (step S3809: Yes), the process returns to step S3805. On the other hand, if a regular element table-element table is not present (step S3809: No), the information processing device 101 determines whether or not there is a regular element table that has not been read (step S3810).

If a regular element table is present (step S3810: Yes), the information processing device 101 returns to step S3801. On the other hand, if a regular element table is not present (step S3810: No), the information processing device 101 returns to the step where the space insertion process was called.

This allows you to define blank areas where nothing is defined.

Next, the specific processing steps of the configuration information output process in step S3103 shown in FIG. 31 will be described using FIG. 39.

Figure 39 is a flowchart showing an example of a specific processing procedure for configuration information output processing. In the flowchart of Figure 39, first, the information processing device 101 reads the regular element table (step S3901). Next, the information processing device 101 reads the regular element table - element table, and outputs the element name to the screen configuration information (step S3902).

Then, the information processing device 101 outputs the separator "," to the screen configuration information (step S3903). Next, the information processing device 101 determines whether or not there is an unread regular element table-element table (step S3904). Here, if there is an unread regular element table-element table (step S3904: Yes), the information processing device 101 returns to step S3902.

On the other hand, if there are no unread regular element tables-element tables (step S3904: No), the information processing device 101 outputs "NewLine" representing a line break to the screen configuration information (step S3905). Next, the information processing device 101 outputs the separator character "," to the screen configuration information (step S3906).

Then, the information processing device 101 determines whether or not there is an unread regular element table (step S3907). If there is an unread regular element table (step S3907: Yes), the information processing device 101 returns to step S3901. On the other hand, if there is no unread regular element table (step S3907: No), the information processing device 101 returns to the step that called the configuration information output process.

This allows the regular element table nt to be encoded and screen configuration information to be output.

As described above, according to the information processing device 101 of the embodiment, for each of the first screen of the first system and the second screen of the second system, information on the multiple elements constituting the screen can be extracted from a screen definition file that defines the configuration of the screen. Then, according to the information processing device 101, for each screen, normalization processing can be performed based on the information on the multiple elements extracted, and the results of the normalization processing performed for each screen can be output. The normalization processing is processing that makes it possible to distinguish the type of each of the multiple elements, the element name of each of the multiple elements, and the relative positional relationship between the multiple elements according to predetermined normalization rules, and eliminates differences in the display shape and size between the screens of each of the multiple elements.

This makes it possible to absorb differences in the unique expressions of screen definitions and provide information that can be used to verify that there are no omissions in screen components before and after the system migration, and that there is no change in the relative positions of screen components before and after the migration.

In addition, the information processing device 101 can compare the results of the normalization process performed on each screen and output the comparison results.

This makes it easy to verify that there are no omissions in the screen components before and after the system migration, and that there are no changes in the relative positions of the screen components before and after the migration.

In addition, according to the information processing device 101, the normalization process can further make it possible to distinguish the relative magnitude relationships between multiple elements.

This allows us to verify whether the relative size relationships between elements in the screen configuration before the transition are maintained in the screen configuration after the transition.

In addition, according to the information processing device 101, information regarding elements that represent at least one of input items, output items, literals, buttons, and images as elements that constitute a screen can be extracted from the screen definition file.

This allows you to verify that there are no omissions and that there are no changes in the relative positions of components such as input fields, output fields, fixed literals (constants), buttons, and images before and after the migration.

In addition, according to the information processing device 101, information regarding elements that represent blank spaces as elements that make up a screen can be extracted from the screen definition file.

This makes it possible to verify, for example, that there are no omissions, including white space between elements, and that there are no changes in positional relationships before and after the transition.

In addition, according to the information processing device 101, the normalization process can further make the values of each of the multiple elements distinguishable.

This allows you to verify that the element values (initial values, item names, button names, etc.) in the screen configuration before migration are the same in the screen configuration after migration.

In addition, according to the information processing device 101, for each screen, the screen is divided row-wise based on the vertical position and vertical size of each of a plurality of elements, and for each divided area, element names including the type of element appearing in the row direction in the area can be listed, and when the area switches row-wise, screen configuration information can be created in which an element name including a type representing a line break is inserted. For example, when the element type is other than a line break or a space, the element name includes the element type and an identification number indicating the order in which elements of that type were declared on the screen (the order in which the elements appear on the screen).

This makes it possible to create screen configuration information that indicates, for example, what types of elements appear and in what order when elements are scanned in the row-column direction, starting from the top left corner of the screen.

In addition, according to the information processing device 101, for each screen, the screen is divided into regions in the column direction based on the horizontal position and horizontal size of each of a plurality of elements, and for each region, element names including the types of elements that appear in the row direction in the region are listed, and when the region switches in the column direction, screen configuration information can be created in which element names including a type indicating a line break are inserted.

This makes it possible to create screen configuration information that indicates, for example, what types of elements appear and in what order when elements are scanned row-wise, starting from the top left corner of the screen.

For these reasons, the information processing device 101 normalizes the components of the screen definition files of each screen before and after the migration, making it possible to compare the screen configurations before and after the migration without being influenced by the specific expressions in the screen definition files or the strict positions of elements. This makes it easy to verify the screen configurations before and after the migration, reducing the workload and time required to verify the screen configuration associated with system migration.

For example, by normalizing the components of a screen definition file, it is possible to prevent screens with the same configuration from being judged as different screens due to differences in the specific expressions of the screen definition file or the exact positions of elements, as in the case of screen comparison using screen captures. Also, by normalizing the components of a screen definition file, it is possible to verify the screen configuration before and after migration without starting a program. Therefore, for example, even if it is not possible to display the screens before and after migration side by side due to differences in the operating environment, it is possible to verify the screen configuration. Also, by using multiple normalization rules, it is possible to perform verification from multiple perspectives.

The verification method described in this embodiment can be realized by executing a prepared program on a computer such as a personal computer or a workstation. This verification program is recorded on a computer-readable recording medium such as a hard disk, flexible disk, CD-ROM, DVD, or USB memory, and is executed by being read from the recording medium by the computer. This verification program may also be distributed via a network such as the Internet.

The information processing device 101 described in this embodiment can also be realized by application-specific ICs such as standard cells or structured ASICs (Application Specific Integrated Circuits) or PLDs (Programmable Logic Devices) such as FPGAs.

The following additional notes are provided with respect to the above-described embodiment.

(Note 1) For each of a first screen of a first system and a second screen of a second system to which the first system is migrated, information on a plurality of elements constituting the screen is extracted from a screen definition file that defines the configuration of the screen;
performing a normalization process for each of the screens based on the extracted information on the plurality of elements and in accordance with a predetermined normalization rule, which makes it possible to distinguish the type of each of the plurality of elements, the element name of each of the plurality of elements, and the relative positional relationship between the plurality of elements, and eliminates differences in display shape and size between the screens of each of the plurality of elements;
outputting a result of the normalization process performed on each of the screens;
A verification program that causes a computer to execute a process.

(Supplementary Note 2) A process is executed by the computer to compare results of the normalization process executed for each of the screens;
The output process includes:
2. The verification program according to claim 1, further comprising: outputting a result of the comparison.

(Additional Note 3) The process of performing the normalization process includes:
The verification program according to claim 1 or 2, further comprising making it possible to distinguish the relative magnitude relationship between the elements of the plurality of elements.

(Appendix 4) The validation program described in any one of appendices 1 to 3, characterized in that the multiple elements include elements representing at least one of an input item, an output item, a literal, a button, and an image.

(Appendix 5) The validation program described in Appendix 4, characterized in that the multiple elements include an element that represents a space.

(Additional Note 6) The process of performing the normalization process includes:
The verification program according to any one of claims 1 to 5, further comprising making the values of the plurality of elements distinguishable.

(Additional Note 7) The process of performing the normalization process includes:
The verification program described in Appendix 1 is characterized in that for each of the screens, the program divides the screen row-wise into regions based on the vertical position and vertical size of each of the multiple elements, lists element names including the types of elements that appear in the region row-wise, and creates screen configuration information in which, when the region switches row-wise, an element name including a type indicating a line break is inserted.

(Additional Note 8) The process of performing the normalization process includes:
The verification program described in Appendix 1 is characterized in that, for each of the screens, the screen is divided in a column direction based on the horizontal position and horizontal size of each of the multiple elements, and for each area divided into the screen in the column direction, element names including the type of elements that appear in the row direction in the area are listed, and when the area switches to the column direction, screen configuration information is created in which element names including a type indicating a line break are inserted.

(Appendix 9) For each of the first screen of the first system and the second screen of the second system to which the first system is migrated, information on a plurality of elements constituting the screen is extracted from a screen definition file that defines the configuration of the screen;
performing a normalization process for each of the screens based on the extracted information on the plurality of elements and in accordance with a predetermined normalization rule, which makes it possible to distinguish the type of each of the plurality of elements, the element name of each of the plurality of elements, and the relative positional relationship between the plurality of elements, and eliminates differences in display shape and size between the screens of each of the plurality of elements;
outputting a result of the normalization process performed on each of the screens;
A verification method comprising the steps of: causing a computer to execute a process.

(Appendix 10) For each of the first screen of the first system and the second screen of the second system to which the first system is migrated, information on a plurality of elements constituting the screen is extracted from a screen definition file that defines the configuration of the screen;
performing a normalization process for each of the screens based on the extracted information on the plurality of elements and in accordance with a predetermined normalization rule, which makes it possible to distinguish the type of each of the plurality of elements, the element name of each of the plurality of elements, and the relative positional relationship between the plurality of elements, and eliminates differences in display shape and size between the screens of each of the plurality of elements;
outputting a result of the normalization process performed on each of the screens;
An information processing device comprising a control unit.

101 Information processing device 110, 120 Screen definition file 111, 121, 2200, 2900 Screen configuration information 200 Bus 201 CPU
202 Memory 203 Disk drive 204 Disk 205 Communication I/F
206, 306 Display 207 Input device 208 Portable recording medium I/F
209 Portable recording medium 210 Network 301 Acquisition unit 302 Extraction unit 303 Normalization unit 304 Comparison unit 305 Output unit 400 First screen 500 Second screen 600 HTML file 1010 Screen definition information 1011, 1600, 2300 Element table 1020 Normalized element table 3000 Output screen

Claims (8)

extracting information on a plurality of elements constituting a first screen of a first system and a second screen of a second system to which the first system is migrated from a screen definition file that defines a configuration of the screen;
performing a normalization process for each of the screens based on the extracted information on the plurality of elements and in accordance with a predetermined normalization rule, which makes it possible to distinguish the type of each of the plurality of elements, the element name of each of the plurality of elements, and the relative positional relationship between the plurality of elements, and eliminates differences in display shape and size between the screens of each of the plurality of elements;
outputting a result of the normalization process performed on each of the screens;
A verification program that causes a computer to execute a process. causing the computer to perform a process of comparing results of the normalization process performed on each of the screens;
The output process includes:
2. The verification program according to claim 1, further comprising: outputting a result of the comparison. The process of performing the normalization process includes:
3. The verification program according to claim 1, further comprising: making it possible to distinguish relative magnitude relationships between the elements of the plurality of elements. The verification program according to any one of claims 1 to 3, characterized in that the multiple elements include elements representing at least one of an input item, an output item, a literal, a button, and an image. The verification program according to claim 4, characterized in that the plurality of elements includes an element representing a space. The process of performing the normalization process includes:
The verification program according to claim 1, characterized in that for each of the screens, the program divides the screen row-wise based on the vertical position and vertical size of each of the multiple elements, and for each area divided into the screen row-wise, lists element names including the types of elements that appear in the area column-wise, and creates screen configuration information in which element names including a type indicating a line break are inserted when the area switches row-wise. extracting information on a plurality of elements constituting a first screen of a first system and a second screen of a second system to which the first system is migrated from a screen definition file that defines a configuration of the screen;
performing a normalization process for each of the screens based on the extracted information on the plurality of elements and in accordance with a predetermined normalization rule, which makes it possible to distinguish the type of each of the plurality of elements, the element name of each of the plurality of elements, and the relative positional relationship between the plurality of elements, and eliminates differences in display shape and size between the screens of each of the plurality of elements;
outputting a result of the normalization process performed on each of the screens;
A verification method comprising the steps of: causing a computer to execute a process. extracting information on a plurality of elements constituting a first screen of a first system and a second screen of a second system to which the first system is migrated from a screen definition file that defines a configuration of the screen;
performing a normalization process for each of the screens based on the extracted information on the plurality of elements and in accordance with a predetermined normalization rule, which makes it possible to distinguish the type of each of the plurality of elements, the element name of each of the plurality of elements, and the relative positional relationship between the plurality of elements, and eliminates differences in display shape and size between the screens of each of the plurality of elements;
outputting a result of the normalization process performed on each of the screens;
An information processing device comprising a control unit.

Images