header = new ArrayList<>();
+
+ // Line 1: Report title at column 44 (report_test.cbl lines 48-50)
+ header.add(String.format("%-43s%s", "", REPORT_TITLE));
+
+ // Line 2: PAGE + number at column 100 (report_test.cbl lines 52-57)
+ header.add(String.format("%-99s%s%3d", "", "PAGE", pageNumber));
+
+ // Lines 3-5: blank lines before first detail
+ header.add("");
+ header.add("");
+ header.add("");
+
+ return header;
+ }
+
+ /**
+ * Formats a single detail line matching the COBOL report-line definition.
+ * Column layout (report_test.cbl lines 59-63):
+ * col 4: student-id (PIC 9(6))
+ * col 15: student-name (PIC X(20))
+ * col 40: major (PIC XXX)
+ * col 46: num-courses (PIC 99)
+ */
+ private String formatDetailLine(StudentRecord record) {
+ return String.format(" %-6d %-20s %-3s %02d",
+ record.getStudentId(),
+ record.getStudentName() != null ? record.getStudentName() : "",
+ record.getMajor() != null ? record.getMajor() : "",
+ record.getNumCourses());
+ }
+}
diff --git a/java-migration/src/main/java/com/cobolmigration/service/SubProgramService.java b/java-migration/src/main/java/com/cobolmigration/service/SubProgramService.java
new file mode 100644
index 0000000..08f24a0
--- /dev/null
+++ b/java-migration/src/main/java/com/cobolmigration/service/SubProgramService.java
@@ -0,0 +1,175 @@
+package com.cobolmigration.service;
+
+import org.springframework.stereotype.Service;
+
+/**
+ * Service replacing the CALL by-content/by-reference pattern from
+ * sub_program/main_app.cbl and sub_program/sub.cbl.
+ *
+ * COBOL subprogram semantics mapping:
+ *
+ * - CALL "sub-app" USING BY CONTENT ws-item-1 BY CONTENT ws-item-2
+ * → Pass immutable/copied values (Java: pass String copies)
+ * - CALL "sub-app" USING ws-item-1 ws-item-2 (BY REFERENCE, default)
+ * → Pass mutable objects (Java: pass mutable wrapper)
+ * - CANCEL "sub-app" → Reset working-storage (Java: {@link #cancel()})
+ *
+ *
+ * COBOL storage section mapping:
+ *
+ * - WORKING-STORAGE SECTION → Instance fields (persist between calls)
+ * - LOCAL-STORAGE SECTION → Method-local variables (fresh each call)
+ * - LINKAGE SECTION → Method parameters
+ *
+ *
+ * @see sub_program/main_app.cbl
+ * @see sub_program/sub.cbl
+ */
+@Service
+public class SubProgramService {
+
+ // Working-storage: persists between calls until cancel() is invoked
+ private String wsTestItem1 = "";
+ private String wsTestItem2 = "";
+
+ /**
+ * Mutable wrapper for by-reference parameter passing.
+ * In COBOL, CALL BY REFERENCE allows the subprogram to modify the caller's variables
+ * (sub_program/main_app.cbl lines 47-48).
+ */
+ public static class MutableString {
+ private String value;
+
+ public MutableString(String value) {
+ this.value = value;
+ }
+
+ public String getValue() {
+ return value;
+ }
+
+ public void setValue(String value) {
+ this.value = value;
+ }
+
+ @Override
+ public String toString() {
+ return value;
+ }
+ }
+
+ /**
+ * Result from a subprogram call, containing the working-storage and local-storage
+ * values at the start and end of execution.
+ */
+ public static class SubProgramResult {
+ private final String wsItem1AtStart;
+ private final String wsItem2AtStart;
+ private final String wsItem1AtEnd;
+ private final String wsItem2AtEnd;
+ private final String outputItem1;
+ private final String outputItem2;
+
+ public SubProgramResult(String wsItem1AtStart, String wsItem2AtStart,
+ String wsItem1AtEnd, String wsItem2AtEnd,
+ String outputItem1, String outputItem2) {
+ this.wsItem1AtStart = wsItem1AtStart;
+ this.wsItem2AtStart = wsItem2AtStart;
+ this.wsItem1AtEnd = wsItem1AtEnd;
+ this.wsItem2AtEnd = wsItem2AtEnd;
+ this.outputItem1 = outputItem1;
+ this.outputItem2 = outputItem2;
+ }
+
+ public String getWsItem1AtStart() { return wsItem1AtStart; }
+ public String getWsItem2AtStart() { return wsItem2AtStart; }
+ public String getWsItem1AtEnd() { return wsItem1AtEnd; }
+ public String getWsItem2AtEnd() { return wsItem2AtEnd; }
+ public String getOutputItem1() { return outputItem1; }
+ public String getOutputItem2() { return outputItem2; }
+ }
+
+ /**
+ * Call by content: passes copies of the values.
+ * The caller's variables are NOT modified (main_app.cbl lines 35-38).
+ *
+ * @param item1 first value (immutable copy)
+ * @param item2 second value (immutable copy)
+ * @return the result showing working-storage state
+ */
+ public SubProgramResult callByContent(String item1, String item2) {
+ // Local-storage: fresh on each call (sub.cbl lines 23-25)
+ String lsTestItem1 = "";
+ String lsTestItem2 = "";
+
+ String wsAtStart1 = wsTestItem1;
+ String wsAtStart2 = wsTestItem2;
+
+ // Move linkage values to working-storage and local-storage (sub.cbl lines 45-48)
+ wsTestItem1 = item1;
+ wsTestItem2 = item2;
+ lsTestItem1 = item1;
+ lsTestItem2 = item2;
+
+ // By content: replacements don't affect caller (sub.cbl lines 52-53)
+ // We return the replaced values but the caller's original strings are unchanged
+ return new SubProgramResult(wsAtStart1, wsAtStart2,
+ wsTestItem1, wsTestItem2,
+ "replace1", "replace2");
+ }
+
+ /**
+ * Call by reference: passes mutable references.
+ * The caller's variables CAN be modified (main_app.cbl lines 47-49).
+ *
+ * @param item1 first value (mutable reference)
+ * @param item2 second value (mutable reference)
+ * @return the result showing working-storage state
+ */
+ public SubProgramResult callByReference(MutableString item1, MutableString item2) {
+ // Local-storage: fresh on each call
+ String lsTestItem1 = "";
+ String lsTestItem2 = "";
+
+ String wsAtStart1 = wsTestItem1;
+ String wsAtStart2 = wsTestItem2;
+
+ // Move linkage values to working-storage and local-storage
+ wsTestItem1 = item1.getValue();
+ wsTestItem2 = item2.getValue();
+ lsTestItem1 = item1.getValue();
+ lsTestItem2 = item2.getValue();
+
+ // By reference: modifications are visible to the caller (sub.cbl lines 52-53)
+ item1.setValue("replace1");
+ item2.setValue("replace2");
+
+ return new SubProgramResult(wsAtStart1, wsAtStart2,
+ wsTestItem1, wsTestItem2,
+ item1.getValue(), item2.getValue());
+ }
+
+ /**
+ * Cancel/reset the subprogram.
+ * Replaces CANCEL "sub-app" (main_app.cbl line 55) which resets
+ * all WORKING-STORAGE variables to their initial values.
+ */
+ public void cancel() {
+ wsTestItem1 = "";
+ wsTestItem2 = "";
+ }
+
+ /**
+ * Returns current working-storage item 1 value for inspection.
+ */
+ public String getWsTestItem1() {
+ return wsTestItem1;
+ }
+
+ /**
+ * Returns current working-storage item 2 value for inspection.
+ */
+ public String getWsTestItem2() {
+ return wsTestItem2;
+ }
+}
diff --git a/java-migration/src/main/java/com/cobolmigration/service/XmlService.java b/java-migration/src/main/java/com/cobolmigration/service/XmlService.java
new file mode 100644
index 0000000..b41c297
--- /dev/null
+++ b/java-migration/src/main/java/com/cobolmigration/service/XmlService.java
@@ -0,0 +1,84 @@
+package com.cobolmigration.service;
+
+import com.cobolmigration.dto.RecordXmlDto;
+import jakarta.xml.bind.JAXBContext;
+import jakarta.xml.bind.JAXBException;
+import jakarta.xml.bind.Marshaller;
+import java.io.StringWriter;
+import org.springframework.stereotype.Service;
+
+/**
+ * Service generating XML from record objects with XML declaration header.
+ * Replaces the COBOL XML GENERATE statement from xml_generate/xml_generate.cbl.
+ *
+ * COBOL equivalent (xml_generate.cbl lines 41-56):
+ *
+ * XML GENERATE ws-xml-output FROM ws-record
+ * COUNT IN ws-xml-char-count
+ * WITH XML-DECLARATION
+ * NAME OF ws-record-name IS "name", ...
+ * TYPE OF ws-record-flag IS ATTRIBUTE
+ * SUPPRESS WHEN SPACES
+ *
+ *
+ * @see xml_generate/xml_generate.cbl
+ */
+@Service
+public class XmlService {
+
+ /**
+ * Generates XML from a RecordXmlDto with XML declaration.
+ * The XML declaration header matches the COBOL WITH XML-DECLARATION option.
+ * The enabled field is rendered as an attribute (TYPE IS ATTRIBUTE).
+ * Fields with only spaces are suppressed (SUPPRESS WHEN SPACES).
+ *
+ * @param record the record to serialize
+ * @return the generated XML string
+ * @throws JAXBException if marshalling fails
+ */
+ public String generateXml(RecordXmlDto record) throws JAXBException {
+ JAXBContext context = JAXBContext.newInstance(RecordXmlDto.class);
+ Marshaller marshaller = context.createMarshaller();
+ marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.FALSE);
+ // WITH XML-DECLARATION: include the header
+ marshaller.setProperty(Marshaller.JAXB_FRAGMENT, Boolean.FALSE);
+
+ StringWriter writer = new StringWriter();
+ marshaller.marshal(record, writer);
+ return writer.toString();
+ }
+
+ /**
+ * Generates XML and returns the character count alongside the output,
+ * matching the COBOL COUNT IN ws-xml-char-count behavior.
+ *
+ * @param record the record to serialize
+ * @return an XmlResult containing the XML string and character count
+ * @throws JAXBException if marshalling fails
+ */
+ public XmlResult generateXmlWithCount(RecordXmlDto record) throws JAXBException {
+ String xml = generateXml(record);
+ return new XmlResult(xml, xml.length());
+ }
+
+ /**
+ * Result holder matching COBOL's dual output of XML content and character count.
+ */
+ public static class XmlResult {
+ private final String xml;
+ private final int charCount;
+
+ public XmlResult(String xml, int charCount) {
+ this.xml = xml;
+ this.charCount = charCount;
+ }
+
+ public String getXml() {
+ return xml;
+ }
+
+ public int getCharCount() {
+ return charCount;
+ }
+ }
+}
diff --git a/java-migration/src/main/java/com/cobolmigration/util/NumericUtils.java b/java-migration/src/main/java/com/cobolmigration/util/NumericUtils.java
new file mode 100644
index 0000000..4c74ce9
--- /dev/null
+++ b/java-migration/src/main/java/com/cobolmigration/util/NumericUtils.java
@@ -0,0 +1,119 @@
+package com.cobolmigration.util;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
+/**
+ * Utility class replacing COBOL COMP/COMP-3 numeric handling from comp_test/comp_test.cbl.
+ *
+ * In COBOL, numeric storage types include:
+ *
+ * - COMP (binary) - stored as binary integer, used for subscripts and calculations
+ * - COMP-2 (double-precision floating point) - used in numval_test/numval_test.cbl
+ * - COMP-3 (packed decimal) - BCD encoding for financial calculations
+ * - COMP-5 (native binary) - used in sql_example.cbl for variable-length strings
+ * - DISPLAY (default) - stored as characters, one byte per digit
+ *
+ *
+ * In Java, we use BigDecimal for precision-sensitive calculations, replacing all
+ * COMP variants to avoid floating-point precision loss.
+ *
+ * @see comp_test/comp_test.cbl
+ * @see numval_test/numval_test.cbl
+ */
+public final class NumericUtils {
+
+ private NumericUtils() {
+ // Utility class - prevent instantiation
+ }
+
+ /**
+ * Converts a COBOL COMP (binary) value representation to BigDecimal.
+ * In COBOL, COMP stores values as binary integers (comp_test.cbl line 13: PIC 999 COMP).
+ *
+ * @param value the integer value
+ * @return BigDecimal representation
+ */
+ public static BigDecimal fromComp(int value) {
+ return BigDecimal.valueOf(value);
+ }
+
+ /**
+ * Converts a COBOL COMP-2 (double-precision float) value to BigDecimal.
+ * Used in numval_test.cbl (line 17: ws-total COMP-2).
+ *
+ * @param value the double value
+ * @return BigDecimal representation with controlled precision
+ */
+ public static BigDecimal fromComp2(double value) {
+ return BigDecimal.valueOf(value);
+ }
+
+ /**
+ * Converts a COBOL COMP-3 (packed decimal) conceptual value to BigDecimal.
+ * COMP-3 stores two digits per byte in BCD format.
+ * In Java, BigDecimal natively handles decimal precision.
+ *
+ * @param value the string representation of the packed decimal value
+ * @param scale the number of decimal places implied by the COBOL PIC clause
+ * @return BigDecimal with the correct scale
+ */
+ public static BigDecimal fromComp3(String value, int scale) {
+ BigDecimal result = new BigDecimal(value.trim());
+ return result.setScale(scale, RoundingMode.HALF_UP);
+ }
+
+ /**
+ * Formats a BigDecimal to a COBOL DISPLAY format string.
+ * Replaces the COBOL MOVE of COMP to DISPLAY (comp_test.cbl lines 27-28).
+ *
+ * @param value the BigDecimal to format
+ * @param width the total character width (PIC 999 = width 3)
+ * @return zero-padded string representation
+ */
+ public static String toDisplay(BigDecimal value, int width) {
+ if (value == null) {
+ return "0".repeat(width);
+ }
+ long longVal = value.longValue();
+ return String.format("%0" + width + "d", longVal);
+ }
+
+ /**
+ * Formats a BigDecimal to a COBOL dynamic display format (suppressed leading zeros).
+ * Replaces the PIC ZZ9 format (comp_test.cbl line 17).
+ *
+ * @param value the BigDecimal to format
+ * @param width the total character width
+ * @return right-justified string with leading spaces instead of zeros
+ */
+ public static String toDynamicDisplay(BigDecimal value, int width) {
+ if (value == null) {
+ return " ".repeat(width - 1) + "0";
+ }
+ return String.format("%" + width + "d", value.longValue());
+ }
+
+ /**
+ * Multiplies two values, equivalent to COBOL MULTIPLY ... GIVING.
+ * Uses BigDecimal for precision (comp_test.cbl line 24).
+ *
+ * @param a first operand
+ * @param b second operand
+ * @return product as BigDecimal
+ */
+ public static BigDecimal multiply(BigDecimal a, BigDecimal b) {
+ return a.multiply(b);
+ }
+
+ /**
+ * Adds two values, equivalent to COBOL ADD or COMPUTE.
+ *
+ * @param a first operand
+ * @param b second operand
+ * @return sum as BigDecimal
+ */
+ public static BigDecimal add(BigDecimal a, BigDecimal b) {
+ return a.add(b);
+ }
+}
diff --git a/java-migration/src/main/java/com/cobolmigration/util/StringUtils.java b/java-migration/src/main/java/com/cobolmigration/util/StringUtils.java
new file mode 100644
index 0000000..d3faefc
--- /dev/null
+++ b/java-migration/src/main/java/com/cobolmigration/util/StringUtils.java
@@ -0,0 +1,159 @@
+package com.cobolmigration.util;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * Utility class replacing COBOL string/data operations:
+ *
+ * - TRIM intrinsic function → {@link #trim(String)}, {@link #trimLeading(String)},
+ * {@link #trimTrailing(String)} (from trim/trim.cbl)
+ * - UNSTRING statement → {@link #unstring(String, String...)} (from unstring/unstring.cbl)
+ * - IS NUMERIC class condition → {@link #isNumeric(String)} (from is_numeric/is_numeric.cbl)
+ * - NUMVAL intrinsic function → {@link #numval(String)} (from numval_test/numval_test.cbl)
+ *
+ *
+ * @see trim/trim.cbl
+ * @see unstring/unstring.cbl
+ * @see is_numeric/is_numeric.cbl
+ * @see numval_test/numval_test.cbl
+ */
+public final class StringUtils {
+
+ private static final Pattern NUMERIC_PATTERN = Pattern.compile("-?\\d+(\\.\\d+)?");
+
+ private StringUtils() {
+ // Utility class - prevent instantiation
+ }
+
+ /**
+ * Replaces COBOL FUNCTION TRIM(value).
+ * Removes both leading and trailing spaces, equivalent to COBOL's default TRIM.
+ *
+ * @see trim/trim.cbl line 23
+ */
+ public static String trim(String value) {
+ if (value == null) {
+ return "";
+ }
+ return value.trim();
+ }
+
+ /**
+ * Replaces COBOL FUNCTION TRIM(value LEADING).
+ * Removes leading spaces only.
+ *
+ * @see trim/trim.cbl line 24
+ */
+ public static String trimLeading(String value) {
+ if (value == null) {
+ return "";
+ }
+ return value.stripLeading();
+ }
+
+ /**
+ * Replaces COBOL FUNCTION TRIM(value TRAILING).
+ * Removes trailing spaces only.
+ *
+ * @see trim/trim.cbl line 25
+ */
+ public static String trimTrailing(String value) {
+ if (value == null) {
+ return "";
+ }
+ return value.stripTrailing();
+ }
+
+ /**
+ * Replaces the COBOL UNSTRING statement with multiple delimiters.
+ * Splits a source string by one or more delimiter patterns.
+ *
+ * In COBOL, UNSTRING splits a source string into destination fields
+ * based on specified delimiters (unstring/unstring.cbl lines 58-61).
+ *
+ * @param source the source string to split
+ * @param delimiters one or more delimiter strings
+ * @return list of parts after splitting
+ * @see unstring/unstring.cbl
+ */
+ public static List unstring(String source, String... delimiters) {
+ if (source == null || delimiters == null || delimiters.length == 0) {
+ List result = new ArrayList<>();
+ if (source != null) {
+ result.add(source);
+ }
+ return result;
+ }
+
+ // Build a regex pattern from all delimiters, escaping special regex chars
+ StringBuilder patternBuilder = new StringBuilder();
+ for (int i = 0; i < delimiters.length; i++) {
+ if (i > 0) {
+ patternBuilder.append("|");
+ }
+ patternBuilder.append(Pattern.quote(delimiters[i]));
+ }
+
+ String[] parts = source.split(patternBuilder.toString(), -1);
+ List result = new ArrayList<>();
+ for (String part : parts) {
+ result.add(part);
+ }
+ return result;
+ }
+
+ /**
+ * Replaces the COBOL IS NUMERIC class condition.
+ * In COBOL, a PIC X field IS NUMERIC only if all characters are contiguous digits
+ * (is_numeric/is_numeric.cbl). Spaces cause the test to fail unless the value is trimmed first.
+ *
+ * @param value the string to test
+ * @return true if the trimmed value represents a valid number
+ * @see is_numeric/is_numeric.cbl
+ */
+ public static boolean isNumeric(String value) {
+ if (value == null || value.trim().isEmpty()) {
+ return false;
+ }
+ return NUMERIC_PATTERN.matcher(value.trim()).matches();
+ }
+
+ /**
+ * Replaces the COBOL FUNCTION NUMVAL(value).
+ * Converts an alphanumeric PIC X value to a numeric BigDecimal.
+ * In COBOL, NUMVAL converts a string representation of a number to its numeric
+ * equivalent (numval_test/numval_test.cbl line 28).
+ *
+ * @param value the string to parse
+ * @return the numeric value as BigDecimal
+ * @throws NumberFormatException if the value cannot be parsed
+ * @see numval_test/numval_test.cbl
+ */
+ public static BigDecimal numval(String value) {
+ if (value == null || value.trim().isEmpty()) {
+ throw new NumberFormatException("Cannot parse null or empty value");
+ }
+ return new BigDecimal(value.trim());
+ }
+
+ /**
+ * Pads a string to a fixed width with trailing spaces, mimicking COBOL's PIC X(n) behavior.
+ * COBOL alphanumeric fields are always space-padded to their defined length.
+ *
+ * @param value the string to pad
+ * @param width the target width
+ * @return the padded string
+ */
+ public static String padRight(String value, int width) {
+ if (value == null) {
+ return " ".repeat(width);
+ }
+ if (value.length() >= width) {
+ return value.substring(0, width);
+ }
+ return value + " ".repeat(width - value.length());
+ }
+}
diff --git a/java-migration/src/main/resources/application-h2.properties b/java-migration/src/main/resources/application-h2.properties
new file mode 100644
index 0000000..3b95ffe
--- /dev/null
+++ b/java-migration/src/main/resources/application-h2.properties
@@ -0,0 +1,13 @@
+# H2 in-memory database for local testing without PostgreSQL
+spring.datasource.url=jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1;MODE=PostgreSQL
+spring.datasource.username=sa
+spring.datasource.password=
+spring.datasource.driver-class-name=org.h2.Driver
+
+spring.jpa.hibernate.ddl-auto=create
+spring.jpa.show-sql=true
+spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect
+spring.jpa.defer-datasource-initialization=true
+
+spring.sql.init.mode=always
+spring.sql.init.data-locations=classpath:data-h2.sql
diff --git a/java-migration/src/main/resources/application.properties b/java-migration/src/main/resources/application.properties
new file mode 100644
index 0000000..37190e3
--- /dev/null
+++ b/java-migration/src/main/resources/application.properties
@@ -0,0 +1,16 @@
+# PostgreSQL connection configuration
+# Maps from the COBOL connection string in sql/sql_example.cbl lines 35-42:
+# DRIVER={PostgreSQL Unicode};SERVER=localhost;PORT=5432;
+# DATABASE=cobol_db_example;UID=postgres;PWD=password;
+spring.datasource.url=jdbc:postgresql://localhost:5432/cobol_db_example
+spring.datasource.username=postgres
+spring.datasource.password=password
+spring.datasource.driver-class-name=org.postgresql.Driver
+
+# JPA/Hibernate settings
+spring.jpa.hibernate.ddl-auto=validate
+spring.jpa.show-sql=false
+spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
+
+# Initialize schema from migration scripts
+spring.sql.init.mode=never
diff --git a/java-migration/src/main/resources/data-h2.sql b/java-migration/src/main/resources/data-h2.sql
new file mode 100644
index 0000000..ac1ac01
--- /dev/null
+++ b/java-migration/src/main/resources/data-h2.sql
@@ -0,0 +1,33 @@
+-- Seed data for H2 testing profile (same as sql/create_test_db.sql)
+INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt)
+VALUES ('John', 'Tester', '15555550100', '123 Fake St, Nowhere', 'Y', NOW(), NOW());
+
+INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt)
+VALUES ('Mike', 'Tester1', '15555550121', '122 Real St, Nowhere', 'Y', NOW(), NOW());
+
+INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt)
+VALUES ('Mary', 'Tester2', '15555550132', '121 ABC St, Nowhere', 'Y', NOW(), NOW());
+
+INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt)
+VALUES ('Jack', 'Tester3', '15555550143', '120 Rock St, Nowhere', 'Y', NOW(), NOW());
+
+INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt)
+VALUES ('Bob', 'Tester4', '15555550154', '119 Truck St, Nowhere', 'N', NOW(), NOW());
+
+INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt)
+VALUES ('Paula', 'Tester5', '1555550165', '118 Car St, Nowhere', 'N', NOW(), NOW());
+
+INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt)
+VALUES ('James', 'Tester6', '1555550176', '117 Land St, Nowhere', 'Y', NOW(), NOW());
+
+INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt)
+VALUES ('Jane', 'Tester7', '1555550187', '116 Sea St, Nowhere', 'Y', NOW(), NOW());
+
+INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt)
+VALUES ('Bill', 'Tester8', '1555550198', '115 Dock St, Nowhere', 'N', NOW(), NOW());
+
+INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt)
+VALUES ('Lucy', 'Tester9', '1555550209', '114 Beach St, Nowhere', 'Y', NOW(), NOW());
+
+INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt)
+VALUES ('Richard', 'Tester10', '1555550210', '113 Water St, Nowhere', 'Y', NOW(), NOW());
diff --git a/java-migration/src/main/resources/db/migration/V1__create_accounts_table.sql b/java-migration/src/main/resources/db/migration/V1__create_accounts_table.sql
new file mode 100644
index 0000000..88bcc3e
--- /dev/null
+++ b/java-migration/src/main/resources/db/migration/V1__create_accounts_table.sql
@@ -0,0 +1,49 @@
+-- Database schema migration for the COBOL-to-Java migration.
+-- Reference: sql/create_test_db.sql from the COBOL project.
+
+CREATE TABLE IF NOT EXISTS accounts (
+ id SERIAL NOT NULL,
+ first_name VARCHAR NOT NULL,
+ last_name VARCHAR NOT NULL,
+ phone VARCHAR NOT NULL,
+ address VARCHAR NOT NULL,
+ is_enabled VARCHAR(1) NOT NULL DEFAULT 'N',
+ create_dt TIMESTAMP DEFAULT NOW(),
+ mod_dt TIMESTAMP DEFAULT NOW(),
+ PRIMARY KEY (id)
+);
+
+-- Populate fake account data (same as the COBOL create_test_db.sql).
+
+INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt)
+VALUES ('John', 'Tester', '15555550100', '123 Fake St, Nowhere', 'Y', NOW(), NOW());
+
+INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt)
+VALUES ('Mike', 'Tester1', '15555550121', '122 Real St, Nowhere', 'Y', NOW(), NOW());
+
+INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt)
+VALUES ('Mary', 'Tester2', '15555550132', '121 ABC St, Nowhere', 'Y', NOW(), NOW());
+
+INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt)
+VALUES ('Jack', 'Tester3', '15555550143', '120 Rock St, Nowhere', 'Y', NOW(), NOW());
+
+INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt)
+VALUES ('Bob', 'Tester4', '15555550154', '119 Truck St, Nowhere', 'N', NOW(), NOW());
+
+INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt)
+VALUES ('Paula', 'Tester5', '1555550165', '118 Car St, Nowhere', 'N', NOW(), NOW());
+
+INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt)
+VALUES ('James', 'Tester6', '1555550176', '117 Land St, Nowhere', 'Y', NOW(), NOW());
+
+INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt)
+VALUES ('Jane', 'Tester7', '1555550187', '116 Sea St, Nowhere', 'Y', NOW(), NOW());
+
+INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt)
+VALUES ('Bill', 'Tester8', '1555550198', '115 Dock St, Nowhere', 'N', NOW(), NOW());
+
+INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt)
+VALUES ('Lucy', 'Tester9', '1555550209', '114 Beach St, Nowhere', 'Y', NOW(), NOW());
+
+INSERT INTO accounts (first_name, last_name, phone, address, is_enabled, create_dt, mod_dt)
+VALUES ('Richard', 'Tester10', '1555550210', '113 Water St, Nowhere', 'Y', NOW(), NOW());
diff --git a/java-migration/src/test/java/com/cobolmigration/controller/AccountControllerTest.java b/java-migration/src/test/java/com/cobolmigration/controller/AccountControllerTest.java
new file mode 100644
index 0000000..af84474
--- /dev/null
+++ b/java-migration/src/test/java/com/cobolmigration/controller/AccountControllerTest.java
@@ -0,0 +1,164 @@
+package com.cobolmigration.controller;
+
+import com.cobolmigration.model.Account;
+import com.cobolmigration.service.AccountService;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.util.List;
+import java.util.Optional;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MockMvc;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.when;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+/**
+ * Integration tests for AccountController REST endpoints.
+ */
+@WebMvcTest(AccountController.class)
+class AccountControllerTest {
+
+ @Autowired
+ private MockMvc mockMvc;
+
+ @MockBean
+ private AccountService accountService;
+
+ @Autowired
+ private ObjectMapper objectMapper;
+
+ @Test
+ @DisplayName("GET /accounts returns all accounts")
+ void testGetAllAccounts() throws Exception {
+ Account account = createTestAccount(1L, "John", "Tester", 'Y');
+ when(accountService.getAllAccounts()).thenReturn(List.of(account));
+
+ mockMvc.perform(get("/accounts"))
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$[0].firstName").value("John"))
+ .andExpect(jsonPath("$[0].lastName").value("Tester"));
+ }
+
+ @Test
+ @DisplayName("GET /accounts/disabled returns disabled accounts")
+ void testGetDisabledAccounts() throws Exception {
+ Account account = createTestAccount(1L, "Bob", "Tester4", 'N');
+ when(accountService.getDisabledAccounts()).thenReturn(List.of(account));
+
+ mockMvc.perform(get("/accounts/disabled"))
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$[0].firstName").value("Bob"))
+ .andExpect(jsonPath("$[0].isEnabled").value("N"));
+ }
+
+ @Test
+ @DisplayName("GET /accounts/search?q=term searches accounts")
+ void testSearchAccounts() throws Exception {
+ Account account = createTestAccount(1L, "John", "Tester", 'Y');
+ when(accountService.searchAccounts("John")).thenReturn(List.of(account));
+
+ mockMvc.perform(get("/accounts/search").param("q", "John"))
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$[0].firstName").value("John"));
+ }
+
+ @Test
+ @DisplayName("GET /accounts/{id} returns account by ID")
+ void testGetAccountById() throws Exception {
+ Account account = createTestAccount(1L, "John", "Tester", 'Y');
+ when(accountService.getAccountById(1L)).thenReturn(Optional.of(account));
+
+ mockMvc.perform(get("/accounts/1"))
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$.firstName").value("John"));
+ }
+
+ @Test
+ @DisplayName("GET /accounts/{id} returns 404 for nonexistent ID")
+ void testGetAccountByIdNotFound() throws Exception {
+ when(accountService.getAccountById(999L)).thenReturn(Optional.empty());
+
+ mockMvc.perform(get("/accounts/999"))
+ .andExpect(status().isNotFound());
+ }
+
+ @Test
+ @DisplayName("POST /accounts creates a new account")
+ void testAddAccount() throws Exception {
+ Account created = createTestAccount(1L, "Jane", "Doe", 'Y');
+ when(accountService.addAccount(anyString(), anyString(), anyString(), anyString()))
+ .thenReturn(created);
+
+ Account request = new Account("Jane", "Doe", "5551234567", "456 St", 'Y');
+
+ mockMvc.perform(post("/accounts")
+ .contentType(MediaType.APPLICATION_JSON)
+ .content(objectMapper.writeValueAsString(request)))
+ .andExpect(status().isCreated())
+ .andExpect(jsonPath("$.firstName").value("Jane"));
+ }
+
+ @Test
+ @DisplayName("PUT /accounts/{id} updates an existing account")
+ void testUpdateAccount() throws Exception {
+ Account updated = createTestAccount(1L, "Updated", "Name", 'Y');
+ when(accountService.updateAccount(anyLong(), anyString(), anyString(), anyString(), anyString()))
+ .thenReturn(Optional.of(updated));
+
+ Account request = new Account("Updated", "Name", "9999999999", "New Address", 'Y');
+
+ mockMvc.perform(put("/accounts/1")
+ .contentType(MediaType.APPLICATION_JSON)
+ .content(objectMapper.writeValueAsString(request)))
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$.firstName").value("Updated"));
+ }
+
+ @Test
+ @DisplayName("DELETE /accounts/{id} deletes an account")
+ void testDeleteAccount() throws Exception {
+ when(accountService.deleteAccount(1L)).thenReturn(true);
+
+ mockMvc.perform(delete("/accounts/1"))
+ .andExpect(status().isNoContent());
+ }
+
+ @Test
+ @DisplayName("DELETE /accounts/{id} returns 404 for nonexistent ID")
+ void testDeleteAccountNotFound() throws Exception {
+ when(accountService.deleteAccount(999L)).thenReturn(false);
+
+ mockMvc.perform(delete("/accounts/999"))
+ .andExpect(status().isNotFound());
+ }
+
+ @Test
+ @DisplayName("PUT /accounts/{id}/toggle toggles enabled status")
+ void testToggleAccountEnabled() throws Exception {
+ Account toggled = createTestAccount(1L, "John", "Tester", 'N');
+ when(accountService.toggleAccountEnabled(1L)).thenReturn(Optional.of(toggled));
+
+ mockMvc.perform(put("/accounts/1/toggle"))
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$.isEnabled").value("N"));
+ }
+
+ private Account createTestAccount(Long id, String firstName, String lastName,
+ Character isEnabled) {
+ Account account = new Account(firstName, lastName, "5551234567", "123 Test St", isEnabled);
+ account.setId(id);
+ return account;
+ }
+}
diff --git a/java-migration/src/test/java/com/cobolmigration/repository/AccountRepositoryTest.java b/java-migration/src/test/java/com/cobolmigration/repository/AccountRepositoryTest.java
new file mode 100644
index 0000000..8640c8a
--- /dev/null
+++ b/java-migration/src/test/java/com/cobolmigration/repository/AccountRepositoryTest.java
@@ -0,0 +1,105 @@
+package com.cobolmigration.repository;
+
+import com.cobolmigration.model.Account;
+import java.util.List;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.test.context.ActiveProfiles;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration tests for AccountRepository validating all three query patterns
+ * that replace the COBOL cursors in sql/sql_example.cbl.
+ */
+@DataJpaTest
+@ActiveProfiles("test")
+class AccountRepositoryTest {
+
+ @Autowired
+ private AccountRepository accountRepository;
+
+ @BeforeEach
+ void setUp() {
+ accountRepository.deleteAll();
+
+ // Seed test data matching sql/create_test_db.sql
+ accountRepository.save(new Account("John", "Tester", "15555550100", "123 Fake St, Nowhere", 'Y'));
+ accountRepository.save(new Account("Mike", "Tester1", "15555550121", "122 Real St, Nowhere", 'Y'));
+ accountRepository.save(new Account("Mary", "Tester2", "15555550132", "121 ABC St, Nowhere", 'Y'));
+ accountRepository.save(new Account("Bob", "Tester4", "15555550154", "119 Truck St, Nowhere", 'N'));
+ accountRepository.save(new Account("Paula", "Tester5", "1555550165", "118 Car St, Nowhere", 'N'));
+ accountRepository.save(new Account("Bill", "Tester8", "1555550198", "115 Dock St, Nowhere", 'N'));
+ }
+
+ @Test
+ @DisplayName("findAllByOrderByIdAsc replaces ACCOUNT-ALL-CUR: returns all accounts sorted by ID")
+ void testFindAllByOrderByIdAsc() {
+ List accounts = accountRepository.findAllByOrderByIdAsc();
+
+ assertThat(accounts).hasSize(6);
+ // Verify ordering by ID ascending
+ for (int i = 1; i < accounts.size(); i++) {
+ assertThat(accounts.get(i).getId())
+ .isGreaterThan(accounts.get(i - 1).getId());
+ }
+ }
+
+ @Test
+ @DisplayName("findByIsEnabledOrderByIdAsc replaces ACCOUNT-DISABLED-CUR: returns only disabled accounts")
+ void testFindByIsEnabledDisabled() {
+ List disabledAccounts = accountRepository.findByIsEnabledOrderByIdAsc('N');
+
+ assertThat(disabledAccounts).hasSize(3);
+ assertThat(disabledAccounts).allMatch(a -> a.getIsEnabled() == 'N');
+ assertThat(disabledAccounts).extracting(Account::getFirstName)
+ .containsExactly("Bob", "Paula", "Bill");
+ }
+
+ @Test
+ @DisplayName("findByIsEnabledOrderByIdAsc returns enabled accounts when queried with 'Y'")
+ void testFindByIsEnabledEnabled() {
+ List enabledAccounts = accountRepository.findByIsEnabledOrderByIdAsc('Y');
+
+ assertThat(enabledAccounts).hasSize(3);
+ assertThat(enabledAccounts).allMatch(a -> a.getIsEnabled() == 'Y');
+ }
+
+ @Test
+ @DisplayName("searchAccounts replaces ACCOUNT-QUERY-CUR: searches across firstName, lastName, phone, address")
+ void testSearchAccountsByFirstName() {
+ List results = accountRepository.searchAccounts("%John%");
+
+ assertThat(results).hasSize(1);
+ assertThat(results.get(0).getFirstName()).isEqualTo("John");
+ }
+
+ @Test
+ @DisplayName("searchAccounts finds matches in lastName field")
+ void testSearchAccountsByLastName() {
+ List results = accountRepository.searchAccounts("%Tester%");
+
+ // All accounts have "Tester" in their last name
+ assertThat(results).hasSize(6);
+ }
+
+ @Test
+ @DisplayName("searchAccounts finds matches in address field")
+ void testSearchAccountsByAddress() {
+ List results = accountRepository.searchAccounts("%Fake%");
+
+ assertThat(results).hasSize(1);
+ assertThat(results.get(0).getAddress()).contains("Fake");
+ }
+
+ @Test
+ @DisplayName("searchAccounts returns empty list for no matches")
+ void testSearchAccountsNoResults() {
+ List results = accountRepository.searchAccounts("%NONEXISTENT%");
+
+ assertThat(results).isEmpty();
+ }
+}
diff --git a/java-migration/src/test/java/com/cobolmigration/service/AccountServiceTest.java b/java-migration/src/test/java/com/cobolmigration/service/AccountServiceTest.java
new file mode 100644
index 0000000..a963249
--- /dev/null
+++ b/java-migration/src/test/java/com/cobolmigration/service/AccountServiceTest.java
@@ -0,0 +1,119 @@
+package com.cobolmigration.service;
+
+import com.cobolmigration.model.Account;
+import com.cobolmigration.repository.AccountRepository;
+import java.util.List;
+import java.util.Optional;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.context.annotation.Import;
+import org.springframework.test.context.ActiveProfiles;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Unit tests for AccountService validating business logic from sql_example.cbl.
+ */
+@DataJpaTest
+@ActiveProfiles("test")
+@Import(AccountService.class)
+class AccountServiceTest {
+
+ @Autowired
+ private AccountService accountService;
+
+ @Autowired
+ private AccountRepository accountRepository;
+
+ @BeforeEach
+ void setUp() {
+ accountRepository.deleteAll();
+ accountRepository.save(new Account("John", "Tester", "15555550100", "123 Fake St", 'Y'));
+ accountRepository.save(new Account("Bob", "Tester4", "15555550154", "119 Truck St", 'N'));
+ }
+
+ @Test
+ @DisplayName("getAllAccounts returns all accounts ordered by ID")
+ void testGetAllAccounts() {
+ List accounts = accountService.getAllAccounts();
+ assertThat(accounts).hasSize(2);
+ }
+
+ @Test
+ @DisplayName("getDisabledAccounts returns only disabled accounts")
+ void testGetDisabledAccounts() {
+ List disabled = accountService.getDisabledAccounts();
+ assertThat(disabled).hasSize(1);
+ assertThat(disabled.get(0).getFirstName()).isEqualTo("Bob");
+ }
+
+ @Test
+ @DisplayName("searchAccounts wraps term with wildcards and finds matches")
+ void testSearchAccounts() {
+ List results = accountService.searchAccounts("Tester");
+ assertThat(results).hasSize(2);
+ }
+
+ @Test
+ @DisplayName("addAccount creates a new enabled account")
+ void testAddAccount() {
+ Account added = accountService.addAccount("Jane", "Doe", "5551234567", "456 New St");
+ assertThat(added.getId()).isNotNull();
+ assertThat(added.getIsEnabled()).isEqualTo('Y');
+ assertThat(added.getCreateDt()).isNotNull();
+ }
+
+ @Test
+ @DisplayName("updateAccount modifies existing account fields")
+ void testUpdateAccount() {
+ Account existing = accountRepository.findAllByOrderByIdAsc().get(0);
+ Optional updated = accountService.updateAccount(
+ existing.getId(), "Updated", "Name", "9999999999", "New Address");
+
+ assertThat(updated).isPresent();
+ assertThat(updated.get().getFirstName()).isEqualTo("Updated");
+ assertThat(updated.get().getModDt()).isNotNull();
+ }
+
+ @Test
+ @DisplayName("updateAccount returns empty for nonexistent ID")
+ void testUpdateNonexistentAccount() {
+ Optional result = accountService.updateAccount(
+ 99999L, "X", "Y", "Z", "W");
+ assertThat(result).isEmpty();
+ }
+
+ @Test
+ @DisplayName("deleteAccount removes an existing account")
+ void testDeleteAccount() {
+ Account existing = accountRepository.findAllByOrderByIdAsc().get(0);
+ boolean deleted = accountService.deleteAccount(existing.getId());
+ assertThat(deleted).isTrue();
+ assertThat(accountRepository.findById(existing.getId())).isEmpty();
+ }
+
+ @Test
+ @DisplayName("deleteAccount returns false for nonexistent ID")
+ void testDeleteNonexistentAccount() {
+ boolean deleted = accountService.deleteAccount(99999L);
+ assertThat(deleted).isFalse();
+ }
+
+ @Test
+ @DisplayName("toggleAccountEnabled flips Y to N and vice versa")
+ void testToggleAccountEnabled() {
+ Account enabledAccount = accountRepository.findAllByOrderByIdAsc().get(0);
+ assertThat(enabledAccount.getIsEnabled()).isEqualTo('Y');
+
+ Optional toggled = accountService.toggleAccountEnabled(enabledAccount.getId());
+ assertThat(toggled).isPresent();
+ assertThat(toggled.get().getIsEnabled()).isEqualTo('N');
+
+ Optional toggledBack = accountService.toggleAccountEnabled(enabledAccount.getId());
+ assertThat(toggledBack).isPresent();
+ assertThat(toggledBack.get().getIsEnabled()).isEqualTo('Y');
+ }
+}
diff --git a/java-migration/src/test/java/com/cobolmigration/service/FileMergeServiceTest.java b/java-migration/src/test/java/com/cobolmigration/service/FileMergeServiceTest.java
new file mode 100644
index 0000000..781ada8
--- /dev/null
+++ b/java-migration/src/test/java/com/cobolmigration/service/FileMergeServiceTest.java
@@ -0,0 +1,83 @@
+package com.cobolmigration.service;
+
+import com.cobolmigration.model.CustomerRecord;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for FileMergeService validating SORT/MERGE logic from merge_sort/merge_sort_test.cbl.
+ */
+class FileMergeServiceTest {
+
+ private final FileMergeService fileMergeService = new FileMergeService();
+
+ @TempDir
+ Path tempDir;
+
+ @Test
+ @DisplayName("mergeFiles merges two files and sorts by customer ID ascending")
+ void testMergeFiles() throws IOException {
+ // Create test data matching merge_sort_test.cbl create-test-data paragraph
+ Path file1 = tempDir.resolve("test-file-1.txt");
+ Path file2 = tempDir.resolve("test-file-2.txt");
+ Path outputFile = tempDir.resolve("merge-output.txt");
+
+ // East region data (file 1) - matches lines 185-259
+ Files.writeString(file1, buildRecord(1, "last-1", "first-1", 5423, "comment-1") + "\n" +
+ buildRecord(5, "last-5", "first-5", 12323, "comment-5") + "\n" +
+ buildRecord(10, "last-10", "first-10", 653, "comment-10") + "\n");
+
+ // West region data (file 2) - matches lines 272-333
+ Files.writeString(file2, buildRecord(999, "last-999", "first-999", 1610, "comment-99") + "\n" +
+ buildRecord(3, "last-03", "first-03", 3331, "comment-03") + "\n");
+
+ List merged = fileMergeService.mergeFiles(file1, file2, outputFile);
+
+ assertThat(merged).hasSize(5);
+ // Verify ascending order by customer ID
+ assertThat(merged.get(0).getCustomerId()).isEqualTo(1);
+ assertThat(merged.get(1).getCustomerId()).isEqualTo(3);
+ assertThat(merged.get(2).getCustomerId()).isEqualTo(5);
+ assertThat(merged.get(3).getCustomerId()).isEqualTo(10);
+ assertThat(merged.get(4).getCustomerId()).isEqualTo(999);
+
+ // Verify output file was written
+ assertThat(Files.exists(outputFile)).isTrue();
+ assertThat(Files.readAllLines(outputFile)).hasSize(5);
+ }
+
+ @Test
+ @DisplayName("sortByContractIdDescending sorts by contract ID in descending order")
+ void testSortByContractIdDescending() throws IOException {
+ Path inputFile = tempDir.resolve("input.txt");
+ Path outputFile = tempDir.resolve("sorted-output.txt");
+
+ Files.writeString(inputFile,
+ buildRecord(1, "last-1", "first-1", 5423, "comment-1") + "\n" +
+ buildRecord(3, "last-03", "first-03", 3331, "comment-03") + "\n" +
+ buildRecord(5, "last-5", "first-5", 12323, "comment-5") + "\n" +
+ buildRecord(10, "last-10", "first-10", 653, "comment-10") + "\n");
+
+ List sorted = fileMergeService.sortByContractIdDescending(inputFile, outputFile);
+
+ assertThat(sorted).hasSize(4);
+ // Verify descending order by contract ID
+ assertThat(sorted.get(0).getContractId()).isEqualTo(12323);
+ assertThat(sorted.get(1).getContractId()).isEqualTo(5423);
+ assertThat(sorted.get(2).getContractId()).isEqualTo(3331);
+ assertThat(sorted.get(3).getContractId()).isEqualTo(653);
+ }
+
+ private String buildRecord(int customerId, String lastName, String firstName,
+ int contractId, String comment) {
+ return String.format("%-5d%-50s%-50s%-5d%-25s",
+ customerId, lastName, firstName, contractId, comment);
+ }
+}
diff --git a/java-migration/src/test/java/com/cobolmigration/service/JsonServiceTest.java b/java-migration/src/test/java/com/cobolmigration/service/JsonServiceTest.java
new file mode 100644
index 0000000..5fa42d2
--- /dev/null
+++ b/java-migration/src/test/java/com/cobolmigration/service/JsonServiceTest.java
@@ -0,0 +1,67 @@
+package com.cobolmigration.service;
+
+import com.cobolmigration.dto.RecordDto;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for JsonService validating JSON generation matching json_generate/json_generate.cbl.
+ */
+class JsonServiceTest {
+
+ private final JsonService jsonService = new JsonService(new ObjectMapper());
+
+ @Test
+ @DisplayName("generateJson produces correct JSON with renamed fields")
+ void testGenerateJson() throws Exception {
+ // Match the COBOL example data (json_generate.cbl lines 38-40)
+ RecordDto record = new RecordDto("Test Name", "Test Value", null, "true");
+
+ String json = jsonService.generateJson(record);
+
+ assertThat(json).contains("\"name\":");
+ assertThat(json).contains("\"Test Name\"");
+ assertThat(json).contains("\"value\":");
+ assertThat(json).contains("\"Test Value\"");
+ assertThat(json).contains("\"enabled\":");
+ assertThat(json).contains("\"true\"");
+ // Blank field should be suppressed (null/empty)
+ assertThat(json).doesNotContain("\"blank\"");
+ }
+
+ @Test
+ @DisplayName("generateJsonWithCount returns character count matching COBOL COUNT IN")
+ void testGenerateJsonWithCount() throws Exception {
+ RecordDto record = new RecordDto("Test Name", "Test Value", null, "true");
+
+ JsonService.JsonResult result = jsonService.generateJsonWithCount(record);
+
+ assertThat(result.getJson()).isNotEmpty();
+ assertThat(result.getCharCount()).isEqualTo(result.getJson().length());
+ assertThat(result.getCharCount()).isGreaterThan(0);
+ }
+
+ @Test
+ @DisplayName("generateJson suppresses blank field when empty (SUPPRESS WHEN SPACES equivalent)")
+ void testSuppressBlankField() throws Exception {
+ RecordDto record = new RecordDto("Name", "Value", "", "false");
+
+ String json = jsonService.generateJson(record);
+
+ assertThat(json).doesNotContain("\"blank\"");
+ }
+
+ @Test
+ @DisplayName("generateJson includes blank field when non-empty")
+ void testNonEmptyBlankField() throws Exception {
+ RecordDto record = new RecordDto("Name", "Value", "NotBlank", "false");
+
+ String json = jsonService.generateJson(record);
+
+ assertThat(json).contains("\"blank\"");
+ assertThat(json).contains("\"NotBlank\"");
+ }
+}
diff --git a/java-migration/src/test/java/com/cobolmigration/service/ReportServiceTest.java b/java-migration/src/test/java/com/cobolmigration/service/ReportServiceTest.java
new file mode 100644
index 0000000..bd28140
--- /dev/null
+++ b/java-migration/src/test/java/com/cobolmigration/service/ReportServiceTest.java
@@ -0,0 +1,91 @@
+package com.cobolmigration.service;
+
+import com.cobolmigration.model.StudentRecord;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for ReportService validating report formatting matching report_writer/report_test.cbl.
+ */
+class ReportServiceTest {
+
+ private final ReportService reportService = new ReportService();
+
+ @Test
+ @DisplayName("generateReport includes page header with report title")
+ void testReportHeader() {
+ List records = List.of(
+ new StudentRecord(123456, "Test Student", "CSC", 5));
+
+ List report = reportService.generateReport(records);
+
+ // Header should contain the report title
+ assertThat(report.get(0)).contains("Customer Order Report");
+ }
+
+ @Test
+ @DisplayName("generateReport includes page number in header")
+ void testPageNumber() {
+ List records = List.of(
+ new StudentRecord(123456, "Test Student", "CSC", 5));
+
+ List report = reportService.generateReport(records);
+
+ // Second line should contain PAGE and page number
+ assertThat(report.get(1)).contains("PAGE");
+ assertThat(report.get(1)).contains("1");
+ }
+
+ @Test
+ @DisplayName("generateReport includes detail lines with student data")
+ void testDetailLines() {
+ List records = List.of(
+ new StudentRecord(334500, "Test Name", "PHY", 12),
+ new StudentRecord(112233, "Another Name", "CSC", 8));
+
+ List report = reportService.generateReport(records);
+
+ // Detail lines start after 5 header lines
+ String detailLine1 = report.get(5);
+ assertThat(detailLine1).contains("334500");
+ assertThat(detailLine1).contains("Test Name");
+ assertThat(detailLine1).contains("PHY");
+ assertThat(detailLine1).contains("12");
+
+ String detailLine2 = report.get(6);
+ assertThat(detailLine2).contains("112233");
+ assertThat(detailLine2).contains("Another Name");
+ }
+
+ @Test
+ @DisplayName("generateReport handles empty record list")
+ void testEmptyRecords() {
+ List report = reportService.generateReport(List.of());
+
+ // Should still have a page header
+ assertThat(report).isNotEmpty();
+ assertThat(report.get(0)).contains("Customer Order Report");
+ }
+
+ @Test
+ @DisplayName("generateReport creates new page when exceeding max details per page")
+ void testPageBreak() {
+ // Create enough records to trigger a page break (>37 detail lines)
+ StudentRecord[] records = new StudentRecord[40];
+ for (int i = 0; i < 40; i++) {
+ records[i] = new StudentRecord(100000 + i, "Student " + i, "CSC", i % 20);
+ }
+
+ List report = reportService.generateReport(Arrays.asList(records));
+
+ // Should contain two page headers
+ long pageHeaderCount = report.stream()
+ .filter(line -> line.contains("Customer Order Report"))
+ .count();
+ assertThat(pageHeaderCount).isEqualTo(2);
+ }
+}
diff --git a/java-migration/src/test/java/com/cobolmigration/service/SubProgramServiceTest.java b/java-migration/src/test/java/com/cobolmigration/service/SubProgramServiceTest.java
new file mode 100644
index 0000000..e5acdbf
--- /dev/null
+++ b/java-migration/src/test/java/com/cobolmigration/service/SubProgramServiceTest.java
@@ -0,0 +1,86 @@
+package com.cobolmigration.service;
+
+import com.cobolmigration.service.SubProgramService.MutableString;
+import com.cobolmigration.service.SubProgramService.SubProgramResult;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for SubProgramService validating CALL by-content/by-reference patterns
+ * from sub_program/main_app.cbl and sub_program/sub.cbl.
+ */
+class SubProgramServiceTest {
+
+ private SubProgramService subProgramService;
+
+ @BeforeEach
+ void setUp() {
+ subProgramService = new SubProgramService();
+ }
+
+ @Test
+ @DisplayName("callByContent does not modify caller's variables (CALL BY CONTENT)")
+ void testCallByContent() {
+ String item1 = "value1";
+ String item2 = "value2";
+
+ SubProgramResult result = subProgramService.callByContent(item1, item2);
+
+ // Working-storage was empty at start (first call)
+ assertThat(result.getWsItem1AtStart()).isEmpty();
+ assertThat(result.getWsItem2AtStart()).isEmpty();
+
+ // Working-storage was updated during call
+ assertThat(result.getWsItem1AtEnd()).isEqualTo("value1");
+ assertThat(result.getWsItem2AtEnd()).isEqualTo("value2");
+
+ // Caller's variables are NOT modified (by content = copy)
+ assertThat(item1).isEqualTo("value1");
+ assertThat(item2).isEqualTo("value2");
+ }
+
+ @Test
+ @DisplayName("callByReference modifies caller's variables (CALL BY REFERENCE)")
+ void testCallByReference() {
+ MutableString item1 = new MutableString("value1");
+ MutableString item2 = new MutableString("value2");
+
+ SubProgramResult result = subProgramService.callByReference(item1, item2);
+
+ // Caller's variables ARE modified (by reference)
+ assertThat(item1.getValue()).isEqualTo("replace1");
+ assertThat(item2.getValue()).isEqualTo("replace2");
+ }
+
+ @Test
+ @DisplayName("working-storage persists between calls until cancel")
+ void testWorkingStoragePersistence() {
+ // First call sets working-storage values
+ subProgramService.callByContent("first1", "first2");
+ assertThat(subProgramService.getWsTestItem1()).isEqualTo("first1");
+
+ // Second call sees working-storage from first call
+ SubProgramResult result = subProgramService.callByContent("second1", "second2");
+ assertThat(result.getWsItem1AtStart()).isEqualTo("first1");
+ assertThat(result.getWsItem2AtStart()).isEqualTo("first2");
+ }
+
+ @Test
+ @DisplayName("cancel resets working-storage (CANCEL 'sub-app')")
+ void testCancel() {
+ subProgramService.callByContent("value1", "value2");
+ assertThat(subProgramService.getWsTestItem1()).isEqualTo("value1");
+
+ subProgramService.cancel();
+
+ assertThat(subProgramService.getWsTestItem1()).isEmpty();
+ assertThat(subProgramService.getWsTestItem2()).isEmpty();
+
+ // After cancel, working-storage starts empty again
+ SubProgramResult result = subProgramService.callByContent("new1", "new2");
+ assertThat(result.getWsItem1AtStart()).isEmpty();
+ }
+}
diff --git a/java-migration/src/test/java/com/cobolmigration/service/XmlServiceTest.java b/java-migration/src/test/java/com/cobolmigration/service/XmlServiceTest.java
new file mode 100644
index 0000000..00efa35
--- /dev/null
+++ b/java-migration/src/test/java/com/cobolmigration/service/XmlServiceTest.java
@@ -0,0 +1,84 @@
+package com.cobolmigration.service;
+
+import com.cobolmigration.dto.RecordXmlDto;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for XmlService validating XML generation matching xml_generate/xml_generate.cbl.
+ */
+class XmlServiceTest {
+
+ private final XmlService xmlService = new XmlService();
+
+ @Test
+ @DisplayName("generateXml includes XML declaration header (WITH XML-DECLARATION)")
+ void testXmlDeclaration() throws Exception {
+ RecordXmlDto record = new RecordXmlDto("Test Name", "Test Value", null, "true");
+
+ String xml = xmlService.generateXml(record);
+
+ assertThat(xml).startsWith("");
+ }
+
+ @Test
+ @DisplayName("generateXml suppresses blank field when spaces (SUPPRESS WHEN SPACES)")
+ void testSuppressWhenSpaces() throws Exception {
+ RecordXmlDto record = new RecordXmlDto("Test Name", "Test Value", " ", "true");
+
+ String xml = xmlService.generateXml(record);
+
+ // Blank field with only spaces should be suppressed (set to null in constructor)
+ assertThat(xml).doesNotContain("");
+ }
+
+ @Test
+ @DisplayName("generateXml includes blank field when non-empty")
+ void testBlankFieldPresent() throws Exception {
+ RecordXmlDto record = new RecordXmlDto("Name", "Value", "NonBlank", "false");
+
+ String xml = xmlService.generateXml(record);
+
+ assertThat(xml).contains("NonBlank");
+ }
+
+ @Test
+ @DisplayName("generateXml includes name and value elements with renamed tags")
+ void testElementNames() throws Exception {
+ RecordXmlDto record = new RecordXmlDto("Test Name", "Test Value", null, "true");
+
+ String xml = xmlService.generateXml(record);
+
+ assertThat(xml).contains("");
+ assertThat(xml).contains("Test Name");
+ assertThat(xml).contains("");
+ assertThat(xml).contains("Test Value");
+ }
+
+ @Test
+ @DisplayName("generateXmlWithCount returns character count matching COBOL COUNT IN")
+ void testGenerateXmlWithCount() throws Exception {
+ RecordXmlDto record = new RecordXmlDto("Test Name", "Test Value", null, "true");
+
+ XmlService.XmlResult result = xmlService.generateXmlWithCount(record);
+
+ assertThat(result.getXml()).isNotEmpty();
+ assertThat(result.getCharCount()).isEqualTo(result.getXml().length());
+ assertThat(result.getCharCount()).isGreaterThan(0);
+ }
+}
diff --git a/java-migration/src/test/java/com/cobolmigration/util/NumericUtilsTest.java b/java-migration/src/test/java/com/cobolmigration/util/NumericUtilsTest.java
new file mode 100644
index 0000000..9fd7172
--- /dev/null
+++ b/java-migration/src/test/java/com/cobolmigration/util/NumericUtilsTest.java
@@ -0,0 +1,80 @@
+package com.cobolmigration.util;
+
+import java.math.BigDecimal;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for NumericUtils validating replacements for COBOL COMP/COMP-3 numeric handling.
+ *
+ * @see comp_test/comp_test.cbl
+ */
+class NumericUtilsTest {
+
+ @Test
+ @DisplayName("fromComp converts integer to BigDecimal (COMP PIC 999)")
+ void testFromComp() {
+ BigDecimal result = NumericUtils.fromComp(24);
+ assertThat(result).isEqualByComparingTo(new BigDecimal("24"));
+ }
+
+ @Test
+ @DisplayName("fromComp2 converts double to BigDecimal (COMP-2)")
+ void testFromComp2() {
+ BigDecimal result = NumericUtils.fromComp2(123.456);
+ assertThat(result).isEqualByComparingTo(new BigDecimal("123.456"));
+ }
+
+ @Test
+ @DisplayName("fromComp3 parses string with scale (COMP-3)")
+ void testFromComp3() {
+ BigDecimal result = NumericUtils.fromComp3("12345", 2);
+ assertThat(result).isEqualByComparingTo(new BigDecimal("12345.00"));
+ assertThat(result.scale()).isEqualTo(2);
+ }
+
+ @Test
+ @DisplayName("toDisplay formats to zero-padded string (PIC 999)")
+ void testToDisplay() {
+ String result = NumericUtils.toDisplay(new BigDecimal("24"), 3);
+ assertThat(result).isEqualTo("024");
+ }
+
+ @Test
+ @DisplayName("toDynamicDisplay formats with leading spaces (PIC ZZ9)")
+ void testToDynamicDisplay() {
+ String result = NumericUtils.toDynamicDisplay(new BigDecimal("24"), 3);
+ assertThat(result).isEqualTo(" 24");
+ }
+
+ @Test
+ @DisplayName("multiply performs COBOL MULTIPLY...GIVING operation")
+ void testMultiply() {
+ // Mirrors comp_test.cbl: MOVE 12 TO ws-comp-val, MULTIPLY ws-comp-val BY 2
+ BigDecimal result = NumericUtils.multiply(new BigDecimal("12"), new BigDecimal("2"));
+ assertThat(result).isEqualByComparingTo(new BigDecimal("24"));
+ }
+
+ @Test
+ @DisplayName("add performs COBOL ADD/COMPUTE operation")
+ void testAdd() {
+ BigDecimal result = NumericUtils.add(new BigDecimal("100"), new BigDecimal("200"));
+ assertThat(result).isEqualByComparingTo(new BigDecimal("300"));
+ }
+
+ @Test
+ @DisplayName("toDisplay handles null value")
+ void testToDisplayNull() {
+ String result = NumericUtils.toDisplay(null, 3);
+ assertThat(result).isEqualTo("000");
+ }
+
+ @Test
+ @DisplayName("toDynamicDisplay handles null value")
+ void testToDynamicDisplayNull() {
+ String result = NumericUtils.toDynamicDisplay(null, 3);
+ assertThat(result).isEqualTo(" 0");
+ }
+}
diff --git a/java-migration/src/test/java/com/cobolmigration/util/StringUtilsTest.java b/java-migration/src/test/java/com/cobolmigration/util/StringUtilsTest.java
new file mode 100644
index 0000000..2fe0ae8
--- /dev/null
+++ b/java-migration/src/test/java/com/cobolmigration/util/StringUtilsTest.java
@@ -0,0 +1,172 @@
+package com.cobolmigration.util;
+
+import java.math.BigDecimal;
+import java.util.List;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+/**
+ * Tests for StringUtils validating replacements for COBOL TRIM, UNSTRING,
+ * IS NUMERIC, and NUMVAL operations.
+ */
+class StringUtilsTest {
+
+ // --- TRIM tests (from trim/trim.cbl) ---
+
+ @Test
+ @DisplayName("trim removes both leading and trailing spaces")
+ void testTrim() {
+ assertThat(StringUtils.trim(" hello world ")).isEqualTo("hello world");
+ }
+
+ @Test
+ @DisplayName("trimLeading removes only leading spaces")
+ void testTrimLeading() {
+ assertThat(StringUtils.trimLeading(" hello world "))
+ .isEqualTo("hello world ");
+ }
+
+ @Test
+ @DisplayName("trimTrailing removes only trailing spaces")
+ void testTrimTrailing() {
+ assertThat(StringUtils.trimTrailing(" hello world "))
+ .isEqualTo(" hello world");
+ }
+
+ @Test
+ @DisplayName("trim handles null input")
+ void testTrimNull() {
+ assertThat(StringUtils.trim(null)).isEqualTo("");
+ }
+
+ @Test
+ @DisplayName("trim handles string literal with spaces")
+ void testTrimStringLiteral() {
+ assertThat(StringUtils.trim(" String literal ")).isEqualTo("String literal");
+ }
+
+ // --- UNSTRING tests (from unstring/unstring.cbl) ---
+
+ @Test
+ @DisplayName("unstring splits by single space delimiter")
+ void testUnstringSingleDelimiter() {
+ List parts = StringUtils.unstring("Hello World", " ");
+ assertThat(parts).containsExactly("Hello", "World");
+ }
+
+ @Test
+ @DisplayName("unstring splits by multiple delimiters")
+ void testUnstringMultipleDelimiters() {
+ List parts = StringUtils.unstring("AC!D|E", "<", ">", "!", "|");
+ assertThat(parts).containsExactly("A", "B", "C", "D", "E");
+ }
+
+ @Test
+ @DisplayName("unstring handles source with no delimiters")
+ void testUnstringNoDelimiters() {
+ List parts = StringUtils.unstring("Hello");
+ assertThat(parts).containsExactly("Hello");
+ }
+
+ @Test
+ @DisplayName("unstring handles null source")
+ void testUnstringNull() {
+ List parts = StringUtils.unstring(null, " ");
+ assertThat(parts).isEmpty();
+ }
+
+ @Test
+ @DisplayName("unstring with comma and dot delimiters for formatted numbers")
+ void testUnstringFormattedNumber() {
+ // Mirrors unstring.cbl Example 6: unstring formatted number
+ List parts = StringUtils.unstring("123,456.12", ",", ".");
+ assertThat(parts).containsExactly("123", "456", "12");
+ }
+
+ // --- IS NUMERIC tests (from is_numeric/is_numeric.cbl) ---
+
+ @Test
+ @DisplayName("isNumeric returns true for digit-only string")
+ void testIsNumericDigits() {
+ assertThat(StringUtils.isNumeric("12345")).isTrue();
+ }
+
+ @Test
+ @DisplayName("isNumeric returns true for decimal number")
+ void testIsNumericDecimal() {
+ assertThat(StringUtils.isNumeric("123.45")).isTrue();
+ }
+
+ @Test
+ @DisplayName("isNumeric returns true for negative number")
+ void testIsNumericNegative() {
+ assertThat(StringUtils.isNumeric("-42")).isTrue();
+ }
+
+ @Test
+ @DisplayName("isNumeric returns false for string with letters")
+ void testIsNumericWithLetters() {
+ assertThat(StringUtils.isNumeric("abc")).isFalse();
+ }
+
+ @Test
+ @DisplayName("isNumeric returns false for empty/null input")
+ void testIsNumericEmpty() {
+ assertThat(StringUtils.isNumeric("")).isFalse();
+ assertThat(StringUtils.isNumeric(null)).isFalse();
+ }
+
+ @Test
+ @DisplayName("isNumeric handles trimmed value with spaces")
+ void testIsNumericWithSpaces() {
+ // Mirrors the is_numeric.cbl process-trim paragraph
+ assertThat(StringUtils.isNumeric(" 123 ")).isTrue();
+ }
+
+ // --- NUMVAL tests (from numval_test/numval_test.cbl) ---
+
+ @Test
+ @DisplayName("numval parses string to BigDecimal")
+ void testNumval() {
+ BigDecimal result = StringUtils.numval("42");
+ assertThat(result).isEqualByComparingTo(new BigDecimal("42"));
+ }
+
+ @Test
+ @DisplayName("numval handles decimal values")
+ void testNumvalDecimal() {
+ BigDecimal result = StringUtils.numval("123.45");
+ assertThat(result).isEqualByComparingTo(new BigDecimal("123.45"));
+ }
+
+ @Test
+ @DisplayName("numval trims spaces before parsing")
+ void testNumvalWithSpaces() {
+ BigDecimal result = StringUtils.numval(" 100 ");
+ assertThat(result).isEqualByComparingTo(new BigDecimal("100"));
+ }
+
+ @Test
+ @DisplayName("numval throws exception for non-numeric input")
+ void testNumvalInvalid() {
+ assertThatThrownBy(() -> StringUtils.numval("abc"))
+ .isInstanceOf(NumberFormatException.class);
+ }
+
+ // --- padRight tests ---
+
+ @Test
+ @DisplayName("padRight pads to specified width")
+ void testPadRight() {
+ assertThat(StringUtils.padRight("Hello", 10)).isEqualTo("Hello ");
+ }
+
+ @Test
+ @DisplayName("padRight truncates if longer than width")
+ void testPadRightTruncate() {
+ assertThat(StringUtils.padRight("Hello World", 5)).isEqualTo("Hello");
+ }
+}
diff --git a/java-migration/src/test/resources/application-test.properties b/java-migration/src/test/resources/application-test.properties
new file mode 100644
index 0000000..307f16d
--- /dev/null
+++ b/java-migration/src/test/resources/application-test.properties
@@ -0,0 +1,11 @@
+# Test configuration using H2 in-memory database
+spring.datasource.url=jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1;MODE=PostgreSQL
+spring.datasource.username=sa
+spring.datasource.password=
+spring.datasource.driver-class-name=org.h2.Driver
+
+spring.jpa.hibernate.ddl-auto=create-drop
+spring.jpa.show-sql=true
+spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect
+
+spring.sql.init.mode=never