ci(feat): Add additional tests for arithmetic, control.

crates/compiler/src/tests/control.rs

@@ -0,0 +1,88 @@
+use super::common::CommonTestRunner;
+
+/// Tests performing a single paragraph.
+#[test]
+fn perform_single() {
+    CommonTestRunner::new("perform_single")
+        .source(r#"
+IDENTIFICATION DIVISION.
+PROGRAM-ID. PERFORM-SINGLE-TEST.
+
+PROCEDURE DIVISION.
+    PERFORM TEST-PARA.
+    STOP RUN.
+
+    TEST-PARA.
+    DISPLAY "Hello".
+        "#)
+        .expect_output("Hello\n")
+        .run();
+}
+
+/// Tests performing a set of paragraphs.
+#[test]
+fn perform_thru() {
+    CommonTestRunner::new("perform_thru")
+        .source(r#"
+IDENTIFICATION DIVISION.
+PROGRAM-ID. PERFORM-THRU-TEST.
+
+PROCEDURE DIVISION.
+    PERFORM A-PARA THRU C-PARA.
+    STOP RUN.
+
+    A-PARA.
+    DISPLAY "Hello".
+
+    B-PARA.
+    DISPLAY "COBOL".
+
+    C-PARA.
+    DISPLAY "World".
+        "#)
+        .expect_output("HelloCOBOLWorld\n\n\n")
+        .run();
+}
+
+/// Tests performing until a condition is met.
+#[test]
+fn perform_until() {
+    CommonTestRunner::new("perform_until")
+        .source(r#"
+IDENTIFICATION DIVISION.
+PROGRAM-ID. PERFORM-UNTIL-TEST.
+
+DATA DIVISION.
+    WORKING-STORAGE SECTION.
+    01 LIMIT-VAL PIC 9(6) COMP VALUE 0.
+
+PROCEDURE DIVISION.
+    PERFORM TEST-PARA UNTIL LIMIT-VAL >= 3.
+    STOP RUN.
+
+    TEST-PARA.
+    DISPLAY "Hello".
+    ADD 1 TO LIMIT-VAL.
+        "#)
+        .expect_output("HelloHelloHello\n\n\n")
+        .run();
+}
+
+/// Tests performing a paragraph N times.
+#[test]
+fn perform_times() {
+    CommonTestRunner::new("perform_times")
+        .source(r#"
+IDENTIFICATION DIVISION.
+PROGRAM-ID. PERFORM-TIMES-TEST.
+
+PROCEDURE DIVISION.
+    PERFORM TEST-PARA 3 TIMES.
+    STOP RUN.
+
+    TEST-PARA.
+    DISPLAY "Hello".
+        "#)
+        .expect_output("HelloHelloHello\n\n\n")
+        .run();
+}

crates/compiler/src/tests/intrinsics.rs

@@ -1,161 +1,159 @@
 use super::common::CommonTestRunner;
 
-/// Tests that the "MOD" intrinsic functions correctly on an exact
-/// divisor.
+/// Tests that the MOD intrinsic for an exact divisor functions.
 #[test]
 fn mod_exact() {
     CommonTestRunner::new("mod_exact")
         .source(r#"
 IDENTIFICATION DIVISION.
-PROGRAM-ID. MOD-EXACT.
+PROGRAM-ID. MOD-EXACT-TEST.
 
 DATA DIVISION.
     WORKING-STORAGE SECTION.
-    01 OUT-VAL PIC 9(4) COMP.
+    01 INT-VAL PIC 9(4) COMP.
 
 PROCEDURE DIVISION.
-    MOVE FUNCTION MOD(4, 2) TO OUT-VAL.
-    DISPLAY OUT-VAL.
+    MOVE FUNCTION MOD(20, 2) TO INT-VAL.
+    DISPLAY INT-VAL.
 STOP RUN.
         "#)
         .expect_output("0\n")
         .run();
 }
 
-/// Tests that the "MOD" intrinsic functions correctly on an exact
-/// divisor.
+/// Tests that the MOD intrinsic for an non-exact divisor functions.
 #[test]
-fn mod_non_divisor() {
-    CommonTestRunner::new("mod_non_divisor")
+fn mod_non_exact() {
+    CommonTestRunner::new("mod_non_exact")
         .source(r#"
 IDENTIFICATION DIVISION.
-PROGRAM-ID. MOD-NON-DIV.
+PROGRAM-ID. MOD-NON-EXACT-TEST.
 
 DATA DIVISION.
     WORKING-STORAGE SECTION.
-    01 OUT-VAL PIC 9(4) COMP.
+    01 INT-VAL PIC 9(4) COMP.
 
 PROCEDURE DIVISION.
-    MOVE FUNCTION MOD(5, 3) TO OUT-VAL.
-    DISPLAY OUT-VAL.
+    MOVE FUNCTION MOD(16, 3) TO INT-VAL.
+    DISPLAY INT-VAL.
 STOP RUN.
         "#)
-        .expect_output("2\n")
+        .expect_output("1\n")
         .run();
 }
 
-/// Tests that the "LENGTH" intrinsic functions correctly on a zero
-/// length string.
+/// Tests that the LENGTH intrinsic works for a zero-length string.
 #[test]
-fn str_length_zero() {
-    CommonTestRunner::new("str_length_zero")
+fn length_zero() {
+    CommonTestRunner::new("length_zero")
         .source(r#"
 IDENTIFICATION DIVISION.
-PROGRAM-ID. STR-LEN-ZERO.
+PROGRAM-ID. LENGTH-ZERO-TEST.
 
 DATA DIVISION.
     WORKING-STORAGE SECTION.
-    01 OUT-VAL PIC 9(4) COMP.
+    01 STR-VAL PIC X(10) VALUE "".
+    01 INT-VAL PIC 9(10) COMP.
 
 PROCEDURE DIVISION.
-    MOVE FUNCTION LENGTH("") TO OUT-VAL.
-    DISPLAY OUT-VAL.
+    MOVE FUNCTION LENGTH(STR-VAL) TO INT-VAL.
+    DISPLAY INT-VAL.
 STOP RUN.
         "#)
         .expect_output("0\n")
         .run();
 }
 
-/// Tests that the "LENGTH" intrinsic functions correctly on a
-/// non-zero length string.
+/// Tests that the LENGTH intrinsic works for a non-zero length string.
 #[test]
-fn str_length_non_zero() {
-    CommonTestRunner::new("str_length_non_zero")
+fn length_non_zero() {
+    CommonTestRunner::new("length_non_zero")
         .source(r#"
 IDENTIFICATION DIVISION.
-PROGRAM-ID. STR-LEN-NON-ZERO.
+PROGRAM-ID. LENGTH-NON-ZERO-TEST.
 
 DATA DIVISION.
     WORKING-STORAGE SECTION.
-    01 OUT-VAL PIC 9(4) COMP.
+    01 STR-VAL PIC X(10) VALUE "SomeStr".
+    01 INT-VAL PIC 9(10) COMP.
 
 PROCEDURE DIVISION.
-    MOVE FUNCTION LENGTH("SomeLitVal") TO OUT-VAL.
-    DISPLAY OUT-VAL.
+    MOVE FUNCTION LENGTH(STR-VAL) TO INT-VAL.
+    DISPLAY INT-VAL.
 STOP RUN.
         "#)
-        .expect_output("10\n")
+        .expect_output("7\n")
         .run();
 }
 
-/// Tests that the "RANDOM" intrinsic generates different
-/// values on subsequent executions.
+
+/// Tests that the RANDOM intrinsic differs on subsequent calls.
 #[test]
 fn random_differs() {
     CommonTestRunner::new("random_differs")
         .source(r#"
 IDENTIFICATION DIVISION.
-PROGRAM-ID. RANDOM-DIFFERS.
+PROGRAM-ID. RANDOM-DIFFERS-TEST.
 
 DATA DIVISION.
     WORKING-STORAGE SECTION.
-    01 A-VAL PIC S9(4)P9(4) COMP.
-    01 B-VAL PIC S9(4)P9(4) COMP.
+    01 A-VAL PIC 9(4)P9(4) COMP.
+    01 B-VAL PIC 9(4)P9(4) COMP.
 
 PROCEDURE DIVISION.
     MOVE FUNCTION RANDOM() TO A-VAL.
     MOVE FUNCTION RANDOM() TO B-VAL.
-    IF A-VAL = B-VAL THEN
-        DISPLAY "fail"
-    ELSE
+    IF NOT A-VAL = B-VAL THEN
         DISPLAY "pass"
+    ELSE
+        DISPLAY "fail"
     END-IF.
 STOP RUN.
         "#)
         .expect_output("pass\n")
         .run();
 }
 
-/// Tests that the "INTEGER" intrinsic correctly rounds up a given
-/// floating point value.
+/// Tests that the INTEGER intrinsic works for a non-integer equivalent value.
 #[test]
-fn integer_rounds_up() {
-    CommonTestRunner::new("integer_rounds_up")
+fn integer_converts_float() {
+    CommonTestRunner::new("integer_converts_float")
         .source(r#"
 IDENTIFICATION DIVISION.
-PROGRAM-ID. INT-ROUNDS-UP.
+PROGRAM-ID. INT-CONV-FLOAT-TEST.
 
 DATA DIVISION.
     WORKING-STORAGE SECTION.
-    01 OUT-VAL PIC 9(4) COMP.
+    01 FLT-VAL PIC 9(4)P9(4) COMP VALUE 20.43.
+    01 INT-VAL PIC 9(10) COMP.
 
 PROCEDURE DIVISION.
-    MOVE FUNCTION INTEGER(2.398282) TO OUT-VAL.
-    DISPLAY OUT-VAL.
+    MOVE FUNCTION INTEGER(FLT-VAL) TO INT-VAL.
+    DISPLAY INT-VAL.
 STOP RUN.
         "#)
-        .expect_output("3\n")
+        .expect_output("21\n")
         .run();
 }
 
-/// Tests that the "INTEGER" intrinsic correctly converts an exact
-/// floating point value to the equivalent integer.
+/// Tests that the INTEGER intrinsic works for an integer equivalent value.
 #[test]
-fn integer_translates_exact() {
-    CommonTestRunner::new("integer_translates_exact")
+fn integer_converts_int() {
+    CommonTestRunner::new("integer_converts_int")
         .source(r#"
 IDENTIFICATION DIVISION.
-PROGRAM-ID. INT-TRANS-EXACT.
+PROGRAM-ID. INT-CONV-INT-TEST.
 
 DATA DIVISION.
     WORKING-STORAGE SECTION.
-    01 OUT-VAL PIC 9(4) COMP.
+    01 FLT-VAL PIC 9(4)P9(4) COMP VALUE 220.0.
+    01 INT-VAL PIC 9(10) COMP.
 
 PROCEDURE DIVISION.
-    MOVE FUNCTION INTEGER(214.0) TO OUT-VAL.
-    DISPLAY OUT-VAL.
+    MOVE FUNCTION INTEGER(FLT-VAL) TO INT-VAL.
+    DISPLAY INT-VAL.
 STOP RUN.
         "#)
-        .expect_output("214\n")
+        .expect_output("220\n")
         .run();
 }

crates/compiler/src/tests/io.rs

@@ -22,7 +22,7 @@ fn int_display_test() {
     CommonTestRunner::new("display_int")
         .source(r#"
 IDENTIFICATION DIVISION.
-PROGRAM-ID. DISPLAY-DATA-TEST.
+PROGRAM-ID. DISPLAY-INT-DATA-TEST.
 
 DATA DIVISION.
     WORKING-STORAGE SECTION.
@@ -42,7 +42,7 @@ fn float_display_test() {
     CommonTestRunner::new("display_float")
         .source(r#"
 IDENTIFICATION DIVISION.
-PROGRAM-ID. DISPLAY-DATA-TEST.
+PROGRAM-ID. DISPLAY-FLT-DATA-TEST.
 
 DATA DIVISION.
     WORKING-STORAGE SECTION.
@@ -63,7 +63,7 @@ fn interleaved_display_test() {
     CommonTestRunner::new("display_interleaved")
         .source(r#"
 IDENTIFICATION DIVISION.
-PROGRAM-ID. DISPLAY-DATA-TEST.
+PROGRAM-ID. DISPLAY-INTER-DATA-TEST.
 
 DATA DIVISION.
     WORKING-STORAGE SECTION.
@@ -108,14 +108,18 @@ PROGRAM-ID. ACCEPT-INT-TEST.
 
 DATA DIVISION.
     WORKING-STORAGE SECTION.
+<<<<<<< HEAD
     01 INT-VAL PIC 9(4) COMP.
+=======
+    01 INT-VAL PIC 9(8) COMP.
+>>>>>>> db58ecf (ci(feat): Add additional tests for arithmetic, control.)
 
 PROCEDURE DIVISION.
     ACCEPT INT-VAL.
     DISPLAY INT-VAL.
 STOP RUN.
         "#)
-        .expect_output_with_input("2024\n", "2024\n")
+        .expect_output_with_input("9004\n", "9004\n")
         .run();
 }
 
@@ -129,13 +133,13 @@ PROGRAM-ID. ACCEPT-FLT-TEST.
 
 DATA DIVISION.
     WORKING-STORAGE SECTION.
-    01 FLT-VAL PIC S9(4)P9(5) COMP.
+    01 FLT-VAL PIC 9(6)P9(4) COMP.
 
 PROCEDURE DIVISION.
     ACCEPT FLT-VAL.
     DISPLAY FLT-VAL.
 STOP RUN.
         "#)
-        .expect_output_with_input("-1234.5678\n", "-1234.5678\n")
+        .expect_output_with_input("9004.21\n", "9004.21\n")
         .run();
 }