MainframeMaster

COBOL Tutorial

COBOL Boundary Checking

Progress0 of 0 lessons

Introduction to Boundary Checking

Boundary checking in COBOL is a critical defensive programming technique that ensures data values remain within acceptable limits and prevents errors that could compromise program integrity. It's essential for maintaining data quality, preventing runtime failures, and ensuring robust enterprise applications.

Key aspects of boundary checking include:

  • Range Validation: Ensuring values fall within expected ranges
  • Array Bounds Checking: Preventing array index out-of-bounds errors
  • Field Length Validation: Checking string and field length limits
  • Numeric Boundary Testing: Validating numeric value limits
  • Input Validation: Comprehensive input data checking

Numeric Range Boundary Checking

Numeric boundary checking ensures that numeric values fall within acceptable ranges for business logic and system constraints.

Basic Numeric Range Validation

cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
IDENTIFICATION DIVISION.
PROGRAM-ID. BOUNDARY-CHECKING-DEMO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 VALIDATION-DATA.
   05 WS-CUSTOMER-AGE       PIC 9(3).
      88 VALID-AGE          VALUE 18 THRU 120.
      88 MINOR-AGE          VALUE 0 THRU 17.
      88 INVALID-AGE        VALUE 121 THRU 999.
   
   05 WS-ACCOUNT-BALANCE    PIC S9(8)V99.
      88 POSITIVE-BALANCE   VALUE 0.01 THRU 999999.99.
      88 ZERO-BALANCE       VALUE 0.
      88 NEGATIVE-BALANCE   VALUE -999999.99 THRU -0.01.
   
   05 WS-CREDIT-SCORE       PIC 9(3).
      88 EXCELLENT-CREDIT   VALUE 800 THRU 850.
      88 GOOD-CREDIT        VALUE 700 THRU 799.
      88 FAIR-CREDIT        VALUE 600 THRU 699.
      88 POOR-CREDIT        VALUE 300 THRU 599.
      88 INVALID-CREDIT     VALUE 0 THRU 299, 851 THRU 999.
 
01 VALIDATION-RESULTS.
   05 WS-VALIDATION-STATUS  PIC X(1).
      88 VALIDATION-PASS    VALUE 'P'.
      88 VALIDATION-FAIL    VALUE 'F'.
   05 WS-ERROR-COUNT        PIC 9(3) VALUE ZERO.
   05 WS-ERROR-MESSAGE      PIC X(50).
 
PROCEDURE DIVISION.
    DISPLAY "=== Boundary Checking Demonstration ==="
    PERFORM TEST-AGE-BOUNDARIES
    PERFORM TEST-BALANCE-BOUNDARIES
    PERFORM TEST-CREDIT-SCORE-BOUNDARIES
    PERFORM COMPREHENSIVE-BOUNDARY-TEST
    STOP RUN.
 
TEST-AGE-BOUNDARIES.
    DISPLAY "=== Age Boundary Testing ==="
    
    * Test valid age
    MOVE 25 TO WS-CUSTOMER-AGE
    PERFORM VALIDATE-AGE
    
    * Test minor age
    MOVE 16 TO WS-CUSTOMER-AGE
    PERFORM VALIDATE-AGE
    
    * Test invalid age
    MOVE 150 TO WS-CUSTOMER-AGE
    PERFORM VALIDATE-AGE.
 
VALIDATE-AGE.
    IF VALID-AGE
       SET VALIDATION-PASS TO TRUE
       DISPLAY "Age " WS-CUSTOMER-AGE ": VALID"
    ELSE
       IF MINOR-AGE
          SET VALIDATION-FAIL TO TRUE
          MOVE "Age below minimum requirement" TO WS-ERROR-MESSAGE
          DISPLAY "Age " WS-CUSTOMER-AGE ": INVALID - " WS-ERROR-MESSAGE
       ELSE
          IF INVALID-AGE
             SET VALIDATION-FAIL TO TRUE
             MOVE "Age exceeds maximum limit" TO WS-ERROR-MESSAGE
             DISPLAY "Age " WS-CUSTOMER-AGE ": INVALID - " WS-ERROR-MESSAGE
          END-IF
       END-IF
       ADD 1 TO WS-ERROR-COUNT
    END-IF.
 
TEST-BALANCE-BOUNDARIES.
    DISPLAY "=== Balance Boundary Testing ==="
    
    * Test positive balance
    MOVE 1500.75 TO WS-ACCOUNT-BALANCE
    PERFORM VALIDATE-BALANCE
    
    * Test zero balance
    MOVE 0 TO WS-ACCOUNT-BALANCE
    PERFORM VALIDATE-BALANCE
    
    * Test negative balance
    MOVE -250.50 TO WS-ACCOUNT-BALANCE
    PERFORM VALIDATE-BALANCE.
 
VALIDATE-BALANCE.
    IF POSITIVE-BALANCE
       SET VALIDATION-PASS TO TRUE
       DISPLAY "Balance $" WS-ACCOUNT-BALANCE ": VALID POSITIVE"
    ELSE
       IF ZERO-BALANCE
          SET VALIDATION-PASS TO TRUE
          DISPLAY "Balance $" WS-ACCOUNT-BALANCE ": VALID ZERO"
       ELSE
          IF NEGATIVE-BALANCE
             SET VALIDATION-FAIL TO TRUE
             MOVE "Negative balance requires special handling" TO WS-ERROR-MESSAGE
             DISPLAY "Balance $" WS-ACCOUNT-BALANCE ": INVALID - " WS-ERROR-MESSAGE
             ADD 1 TO WS-ERROR-COUNT
          END-IF
       END-IF
    END-IF.
 
TEST-CREDIT-SCORE-BOUNDARIES.
    DISPLAY "=== Credit Score Boundary Testing ==="
    
    * Test excellent credit
    MOVE 825 TO WS-CREDIT-SCORE
    PERFORM VALIDATE-CREDIT-SCORE
    
    * Test good credit
    MOVE 750 TO WS-CREDIT-SCORE
    PERFORM VALIDATE-CREDIT-SCORE
    
    * Test invalid credit
    MOVE 950 TO WS-CREDIT-SCORE
    PERFORM VALIDATE-CREDIT-SCORE.
 
VALIDATE-CREDIT-SCORE.
    IF EXCELLENT-CREDIT
       SET VALIDATION-PASS TO TRUE
       DISPLAY "Credit Score " WS-CREDIT-SCORE ": EXCELLENT"
    ELSE
       IF GOOD-CREDIT
          SET VALIDATION-PASS TO TRUE
          DISPLAY "Credit Score " WS-CREDIT-SCORE ": GOOD"
       ELSE
          IF FAIR-CREDIT
             SET VALIDATION-PASS TO TRUE
             DISPLAY "Credit Score " WS-CREDIT-SCORE ": FAIR"
          ELSE
             IF POOR-CREDIT
                SET VALIDATION-FAIL TO TRUE
                MOVE "Poor credit score" TO WS-ERROR-MESSAGE
                DISPLAY "Credit Score " WS-CREDIT-SCORE ": POOR - " WS-ERROR-MESSAGE
                ADD 1 TO WS-ERROR-COUNT
             ELSE
                IF INVALID-CREDIT
                   SET VALIDATION-FAIL TO TRUE
                   MOVE "Invalid credit score range" TO WS-ERROR-MESSAGE
                   DISPLAY "Credit Score " WS-CREDIT-SCORE ": INVALID - " WS-ERROR-MESSAGE
                   ADD 1 TO WS-ERROR-COUNT
                END-IF
             END-IF
          END-IF
       END-IF
    END-IF.

Array and Table Boundary Checking

Array boundary checking prevents index out-of-bounds errors and ensures safe access to table elements.

Array Bounds Validation

cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
IDENTIFICATION DIVISION.
PROGRAM-ID. ARRAY-BOUNDARY-DEMO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 ARRAY-DATA.
   05 WS-CUSTOMER-TABLE OCCURS 100 TIMES
      INDEXED BY WS-CUSTOMER-INDEX.
      10 WS-CUSTOMER-ID     PIC X(10).
      10 WS-CUSTOMER-NAME   PIC X(30).
      10 WS-CUSTOMER-BALANCE PIC S9(7)V99.
 
01 ARRAY-CONTROL.
   05 WS-TABLE-SIZE         PIC 9(3) VALUE 100.
   05 WS-MIN-INDEX          PIC 9(3) VALUE 1.
   05 WS-MAX-INDEX          PIC 9(3) VALUE 100.
   05 WS-CURRENT-INDEX      PIC 9(3).
   05 WS-ACCESS-COUNT       PIC 9(4) VALUE ZERO.
 
01 BOUNDARY-VALIDATION.
   05 WS-INDEX-VALID        PIC X(1).
      88 INDEX-VALID        VALUE 'Y'.
      88 INDEX-INVALID      VALUE 'N'.
   05 WS-BOUNDARY-ERROR     PIC X(50).
 
PROCEDURE DIVISION.
    DISPLAY "=== Array Boundary Checking Demonstration ==="
    PERFORM INITIALIZE-CUSTOMER-TABLE
    PERFORM TEST-VALID-ARRAY-ACCESS
    PERFORM TEST-INVALID-ARRAY-ACCESS
    PERFORM DEMONSTRATE-SAFE-ARRAY-ACCESS
    STOP RUN.
 
INITIALIZE-CUSTOMER-TABLE.
    DISPLAY "=== Initializing Customer Table ==="
    
    PERFORM VARYING WS-CUSTOMER-INDEX FROM 1 BY 1
       UNTIL WS-CUSTOMER-INDEX > WS-TABLE-SIZE
       
       MOVE WS-CUSTOMER-INDEX TO WS-CUSTOMER-ID(WS-CUSTOMER-INDEX)
       MOVE "Customer" TO WS-CUSTOMER-NAME(WS-CUSTOMER-INDEX)
       MOVE WS-CUSTOMER-INDEX * 100 TO WS-CUSTOMER-BALANCE(WS-CUSTOMER-INDEX)
    END-PERFORM
    
    DISPLAY "Customer table initialized with " WS-TABLE-SIZE " entries".
 
TEST-VALID-ARRAY-ACCESS.
    DISPLAY "=== Testing Valid Array Access ==="
    
    * Test valid index access
    MOVE 50 TO WS-CURRENT-INDEX
    PERFORM VALIDATE-ARRAY-INDEX
    IF INDEX-VALID
       PERFORM ACCESS-CUSTOMER-RECORD
    END-IF.
 
TEST-INVALID-ARRAY-ACCESS.
    DISPLAY "=== Testing Invalid Array Access ==="
    
    * Test invalid index access
    MOVE 150 TO WS-CURRENT-INDEX
    PERFORM VALIDATE-ARRAY-INDEX
    IF INDEX-INVALID
       DISPLAY "Array access prevented: " WS-BOUNDARY-ERROR
    END-IF.
 
DEMONSTRATE-SAFE-ARRAY-ACCESS.
    DISPLAY "=== Safe Array Access Demonstration ==="
    
    * Demonstrate safe array access with boundary checking
    PERFORM VARYING WS-CURRENT-INDEX FROM 0 BY 1
       UNTIL WS-CURRENT-INDEX > 105
       
       PERFORM VALIDATE-ARRAY-INDEX
       IF INDEX-VALID
          PERFORM ACCESS-CUSTOMER-RECORD
       ELSE
          DISPLAY "Skipping invalid index: " WS-CURRENT-INDEX
       END-IF
    END-PERFORM.
 
VALIDATE-ARRAY-INDEX.
    IF WS-CURRENT-INDEX >= WS-MIN-INDEX AND WS-CURRENT-INDEX <= WS-MAX-INDEX
       SET INDEX-VALID TO TRUE
       MOVE SPACES TO WS-BOUNDARY-ERROR
    ELSE
       SET INDEX-INVALID TO TRUE
       IF WS-CURRENT-INDEX < WS-MIN-INDEX
          MOVE "Index below minimum bound" TO WS-BOUNDARY-ERROR
       ELSE
          MOVE "Index above maximum bound" TO WS-BOUNDARY-ERROR
       END-IF
    END-IF.
 
ACCESS-CUSTOMER-RECORD.
    SET WS-CUSTOMER-INDEX TO WS-CURRENT-INDEX
    ADD 1 TO WS-ACCESS-COUNT
    
    DISPLAY "Accessing customer " WS-CURRENT-INDEX ":"
    DISPLAY "  ID: " WS-CUSTOMER-ID(WS-CUSTOMER-INDEX)
    DISPLAY "  Name: " WS-CUSTOMER-NAME(WS-CUSTOMER-INDEX)
    DISPLAY "  Balance: $" WS-CUSTOMER-BALANCE(WS-CUSTOMER-INDEX)
    DISPLAY "  Total accesses: " WS-ACCESS-COUNT.

String and Field Length Boundary Checking

String boundary checking ensures that text data fits within defined field lengths and prevents truncation or overflow issues.

Field Length Validation

cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
IDENTIFICATION DIVISION.
PROGRAM-ID. STRING-BOUNDARY-DEMO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 FIELD-DEFINITIONS.
   05 WS-CUSTOMER-NAME      PIC X(30).
   05 WS-CUSTOMER-ADDRESS   PIC X(50).
   05 WS-CUSTOMER-PHONE     PIC X(15).
   05 WS-CUSTOMER-EMAIL     PIC X(40).
 
01 FIELD-LIMITS.
   05 WS-NAME-MAX-LENGTH    PIC 9(2) VALUE 30.
   05 WS-ADDRESS-MAX-LENGTH PIC 9(2) VALUE 50.
   05 WS-PHONE-MAX-LENGTH   PIC 9(2) VALUE 15.
   05 WS-EMAIL-MAX-LENGTH   PIC 9(2) VALUE 40.
 
01 VALIDATION-CONTROL.
   05 WS-FIELD-LENGTH       PIC 9(2).
   05 WS-FIELD-VALID        PIC X(1).
      88 FIELD-VALID        VALUE 'Y'.
      88 FIELD-INVALID      VALUE 'N'.
   05 WS-TRUNCATION-FLAG    PIC X(1).
      88 TRUNCATION-OCCURRED VALUE 'Y'.
      88 NO-TRUNCATION       VALUE 'N'.
 
PROCEDURE DIVISION.
    DISPLAY "=== String Boundary Checking Demonstration ==="
    PERFORM TEST-VALID-FIELD-LENGTHS
    PERFORM TEST-INVALID-FIELD-LENGTHS
    PERFORM DEMONSTRATE-FIELD-TRUNCATION
    STOP RUN.
 
TEST-VALID-FIELD-LENGTHS.
    DISPLAY "=== Testing Valid Field Lengths ==="
    
    * Test valid customer name
    MOVE "John Smith" TO WS-CUSTOMER-NAME
    PERFORM VALIDATE-FIELD-LENGTH USING WS-CUSTOMER-NAME WS-NAME-MAX-LENGTH
    
    * Test valid address
    MOVE "123 Main Street, Anytown, ST 12345" TO WS-CUSTOMER-ADDRESS
    PERFORM VALIDATE-FIELD-LENGTH USING WS-CUSTOMER-ADDRESS WS-ADDRESS-MAX-LENGTH.
 
TEST-INVALID-FIELD-LENGTHS.
    DISPLAY "=== Testing Invalid Field Lengths ==="
    
    * Test invalid phone number
    MOVE "123-456-7890-EXT-12345" TO WS-CUSTOMER-PHONE
    PERFORM VALIDATE-FIELD-LENGTH USING WS-CUSTOMER-PHONE WS-PHONE-MAX-LENGTH
    
    * Test invalid email
    MOVE "very.long.email.address@verylongdomainname.com" TO WS-CUSTOMER-EMAIL
    PERFORM VALIDATE-FIELD-LENGTH USING WS-CUSTOMER-EMAIL WS-EMAIL-MAX-LENGTH.
 
DEMONSTRATE-FIELD-TRUNCATION.
    DISPLAY "=== Field Truncation Demonstration ==="
    
    * Demonstrate safe field assignment with truncation checking
    MOVE "This is a very long customer name that exceeds the field limit" 
         TO WS-CUSTOMER-NAME
    PERFORM CHECK-FIELD-TRUNCATION USING WS-CUSTOMER-NAME WS-NAME-MAX-LENGTH.
 
VALIDATE-FIELD-LENGTH USING FIELD-NAME MAX-LENGTH.
    COMPUTE WS-FIELD-LENGTH = FUNCTION LENGTH(FUNCTION TRIM(FIELD-NAME))
    
    IF WS-FIELD-LENGTH <= MAX-LENGTH
       SET FIELD-VALID TO TRUE
       DISPLAY "Field length " WS-FIELD-LENGTH " is VALID (max: " MAX-LENGTH ")"
    ELSE
       SET FIELD-INVALID TO TRUE
       DISPLAY "Field length " WS-FIELD-LENGTH " is INVALID (max: " MAX-LENGTH ")"
       DISPLAY "Field content: " FIELD-NAME
    END-IF.
 
CHECK-FIELD-TRUNCATION USING FIELD-NAME MAX-LENGTH.
    COMPUTE WS-FIELD-LENGTH = FUNCTION LENGTH(FUNCTION TRIM(FIELD-NAME))
    
    IF WS-FIELD-LENGTH > MAX-LENGTH
       SET TRUNCATION-OCCURRED TO TRUE
       DISPLAY "WARNING: Field truncation occurred"
       DISPLAY "Original length: " WS-FIELD-LENGTH
       DISPLAY "Maximum allowed: " MAX-LENGTH
       DISPLAY "Truncated field: " FIELD-NAME
    ELSE
       SET NO-TRUNCATION TO TRUE
       DISPLAY "No truncation needed for field length: " WS-FIELD-LENGTH
    END-IF.

Date and Time Boundary Checking

Date and time boundary checking ensures that temporal data falls within valid ranges and business constraints.

Date Range Validation

cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
IDENTIFICATION DIVISION.
PROGRAM-ID. DATE-BOUNDARY-DEMO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 DATE-DATA.
   05 WS-TRANSACTION-DATE   PIC 9(8).
      88 VALID-DATE         VALUE 19000101 THRU 20991231.
      88 FUTURE-DATE        VALUE 20250101 THRU 20991231.
      88 PAST-DATE          VALUE 19000101 THRU 20241231.
   
   05 WS-BIRTH-DATE         PIC 9(8).
      88 VALID-BIRTH-DATE   VALUE 19000101 THRU 20241231.
      88 MINOR-BIRTH-DATE   VALUE 20060101 THRU 20241231.
      88 ADULT-BIRTH-DATE   VALUE 19000101 THRU 20051231.
 
01 DATE-VALIDATION.
   05 WS-CURRENT-DATE       PIC 9(8).
   05 WS-DATE-DIFFERENCE    PIC 9(5).
   05 WS-VALIDATION-RESULT  PIC X(1).
      88 DATE-VALID         VALUE 'Y'.
      88 DATE-INVALID       VALUE 'N'.
 
PROCEDURE DIVISION.
    DISPLAY "=== Date Boundary Checking Demonstration ==="
    PERFORM INITIALIZE-DATE-VALIDATION
    PERFORM TEST-TRANSACTION-DATE-BOUNDARIES
    PERFORM TEST-BIRTH-DATE-BOUNDARIES
    PERFORM DEMONSTRATE-DATE-CALCULATIONS
    STOP RUN.
 
INITIALIZE-DATE-VALIDATION.
    DISPLAY "=== Initializing Date Validation ==="
    ACCEPT WS-CURRENT-DATE FROM DATE YYYYMMDD
    DISPLAY "Current date: " WS-CURRENT-DATE.
 
TEST-TRANSACTION-DATE-BOUNDARIES.
    DISPLAY "=== Testing Transaction Date Boundaries ==="
    
    * Test valid transaction date
    MOVE 20240115 TO WS-TRANSACTION-DATE
    PERFORM VALIDATE-TRANSACTION-DATE
    
    * Test future transaction date
    MOVE 20250115 TO WS-TRANSACTION-DATE
    PERFORM VALIDATE-TRANSACTION-DATE
    
    * Test invalid transaction date
    MOVE 18991231 TO WS-TRANSACTION-DATE
    PERFORM VALIDATE-TRANSACTION-DATE.
 
VALIDATE-TRANSACTION-DATE.
    IF VALID-DATE
       SET DATE-VALID TO TRUE
       DISPLAY "Transaction date " WS-TRANSACTION-DATE ": VALID"
       
       IF FUTURE-DATE
          DISPLAY "  Note: Future transaction date"
       ELSE
          IF PAST-DATE
             DISPLAY "  Note: Past transaction date"
          END-IF
       END-IF
    ELSE
       SET DATE-INVALID TO TRUE
       DISPLAY "Transaction date " WS-TRANSACTION-DATE ": INVALID"
       DISPLAY "  Reason: Date outside valid range"
    END-IF.
 
TEST-BIRTH-DATE-BOUNDARIES.
    DISPLAY "=== Testing Birth Date Boundaries ==="
    
    * Test valid adult birth date
    MOVE 19900115 TO WS-BIRTH-DATE
    PERFORM VALIDATE-BIRTH-DATE
    
    * Test minor birth date
    MOVE 20100115 TO WS-BIRTH-DATE
    PERFORM VALIDATE-BIRTH-DATE
    
    * Test invalid birth date
    MOVE 20250115 TO WS-BIRTH-DATE
    PERFORM VALIDATE-BIRTH-DATE.
 
VALIDATE-BIRTH-DATE.
    IF VALID-BIRTH-DATE
       SET DATE-VALID TO TRUE
       DISPLAY "Birth date " WS-BIRTH-DATE ": VALID"
       
       IF MINOR-BIRTH-DATE
          DISPLAY "  Note: Minor customer"
       ELSE
          IF ADULT-BIRTH-DATE
             DISPLAY "  Note: Adult customer"
          END-IF
       END-IF
    ELSE
       SET DATE-INVALID TO TRUE
       DISPLAY "Birth date " WS-BIRTH-DATE ": INVALID"
       DISPLAY "  Reason: Birth date in the future"
    END-IF.
 
DEMONSTRATE-DATE-CALCULATIONS.
    DISPLAY "=== Date Calculation Demonstration ==="
    
    * Calculate age from birth date
    MOVE 19900115 TO WS-BIRTH-DATE
    PERFORM CALCULATE-AGE.
 
CALCULATE-AGE.
    COMPUTE WS-DATE-DIFFERENCE = WS-CURRENT-DATE - WS-BIRTH-DATE
    COMPUTE WS-DATE-DIFFERENCE = WS-DATE-DIFFERENCE / 10000
    
    DISPLAY "Birth date: " WS-BIRTH-DATE
    DISPLAY "Current date: " WS-CURRENT-DATE
    DISPLAY "Calculated age: " WS-DATE-DIFFERENCE " years"
    
    * Validate calculated age
    IF WS-DATE-DIFFERENCE >= 0 AND WS-DATE-DIFFERENCE <= 150
       DISPLAY "Age calculation: VALID"
    ELSE
       DISPLAY "Age calculation: INVALID - Check birth date"
    END-IF.

Comprehensive Boundary Checking Framework

A comprehensive boundary checking framework provides systematic validation across all data types and scenarios.

Integrated Validation System

cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
IDENTIFICATION DIVISION.
PROGRAM-ID. COMPREHENSIVE-BOUNDARY-DEMO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 INPUT-DATA.
   05 WS-CUSTOMER-ID        PIC X(10).
   05 WS-CUSTOMER-NAME      PIC X(30).
   05 WS-CUSTOMER-AGE       PIC 9(3).
   05 WS-CUSTOMER-BALANCE   PIC S9(8)V99.
   05 WS-TRANSACTION-DATE   PIC 9(8).
 
01 VALIDATION-RULES.
   05 WS-ID-MIN-LENGTH      PIC 9(2) VALUE 5.
   05 WS-ID-MAX-LENGTH      PIC 9(2) VALUE 10.
   05 WS-NAME-MAX-LENGTH    PIC 9(2) VALUE 30.
   05 WS-AGE-MIN            PIC 9(3) VALUE 18.
   05 WS-AGE-MAX            PIC 9(3) VALUE 120.
   05 WS-BALANCE-MIN        PIC S9(8)V99 VALUE -999999.99.
   05 WS-BALANCE-MAX        PIC S9(8)V99 VALUE 999999.99.
 
01 VALIDATION-RESULTS.
   05 WS-OVERALL-STATUS     PIC X(1).
      88 ALL-VALIDATIONS-PASS VALUE 'P'.
      88 SOME-VALIDATIONS-FAIL VALUE 'F'.
   05 WS-VALIDATION-COUNT   PIC 9(2) VALUE ZERO.
   05 WS-ERROR-COUNT        PIC 9(2) VALUE ZERO.
   05 WS-ERROR-MESSAGES OCCURS 10 TIMES.
      10 WS-ERROR-MSG       PIC X(50).
 
PROCEDURE DIVISION.
    DISPLAY "=== Comprehensive Boundary Checking Framework ==="
    PERFORM INITIALIZE-VALIDATION-SYSTEM
    PERFORM TEST-COMPREHENSIVE-VALIDATION
    PERFORM DISPLAY-VALIDATION-RESULTS
    STOP RUN.
 
INITIALIZE-VALIDATION-SYSTEM.
    DISPLAY "=== Initializing Validation System ==="
    
    * Initialize test data
    MOVE "CUST12345" TO WS-CUSTOMER-ID
    MOVE "John Smith" TO WS-CUSTOMER-NAME
    MOVE 25 TO WS-CUSTOMER-AGE
    MOVE 1500.75 TO WS-CUSTOMER-BALANCE
    MOVE 20240115 TO WS-TRANSACTION-DATE
    
    MOVE 0 TO WS-VALIDATION-COUNT
    MOVE 0 TO WS-ERROR-COUNT
    SET ALL-VALIDATIONS-PASS TO TRUE.
 
TEST-COMPREHENSIVE-VALIDATION.
    DISPLAY "=== Comprehensive Validation Test ==="
    
    PERFORM VALIDATE-CUSTOMER-ID
    PERFORM VALIDATE-CUSTOMER-NAME
    PERFORM VALIDATE-CUSTOMER-AGE
    PERFORM VALIDATE-CUSTOMER-BALANCE
    PERFORM VALIDATE-TRANSACTION-DATE.
 
VALIDATE-CUSTOMER-ID.
    ADD 1 TO WS-VALIDATION-COUNT
    
    IF FUNCTION LENGTH(FUNCTION TRIM(WS-CUSTOMER-ID)) >= WS-ID-MIN-LENGTH AND
       FUNCTION LENGTH(FUNCTION TRIM(WS-CUSTOMER-ID)) <= WS-ID-MAX-LENGTH
       DISPLAY "Customer ID validation: PASS"
    ELSE
       SET SOME-VALIDATIONS-FAIL TO TRUE
       ADD 1 TO WS-ERROR-COUNT
       MOVE "Customer ID length invalid" TO WS-ERROR-MSG(WS-ERROR-COUNT)
       DISPLAY "Customer ID validation: FAIL"
    END-IF.
 
VALIDATE-CUSTOMER-NAME.
    ADD 1 TO WS-VALIDATION-COUNT
    
    IF FUNCTION LENGTH(FUNCTION TRIM(WS-CUSTOMER-NAME)) <= WS-NAME-MAX-LENGTH
       DISPLAY "Customer name validation: PASS"
    ELSE
       SET SOME-VALIDATIONS-FAIL TO TRUE
       ADD 1 TO WS-ERROR-COUNT
       MOVE "Customer name too long" TO WS-ERROR-MSG(WS-ERROR-COUNT)
       DISPLAY "Customer name validation: FAIL"
    END-IF.
 
VALIDATE-CUSTOMER-AGE.
    ADD 1 TO WS-VALIDATION-COUNT
    
    IF WS-CUSTOMER-AGE >= WS-AGE-MIN AND WS-CUSTOMER-AGE <= WS-AGE-MAX
       DISPLAY "Customer age validation: PASS"
    ELSE
       SET SOME-VALIDATIONS-FAIL TO TRUE
       ADD 1 TO WS-ERROR-COUNT
       MOVE "Customer age out of range" TO WS-ERROR-MSG(WS-ERROR-COUNT)
       DISPLAY "Customer age validation: FAIL"
    END-IF.
 
VALIDATE-CUSTOMER-BALANCE.
    ADD 1 TO WS-VALIDATION-COUNT
    
    IF WS-CUSTOMER-BALANCE >= WS-BALANCE-MIN AND WS-CUSTOMER-BALANCE <= WS-BALANCE-MAX
       DISPLAY "Customer balance validation: PASS"
    ELSE
       SET SOME-VALIDATIONS-FAIL TO TRUE
       ADD 1 TO WS-ERROR-COUNT
       MOVE "Customer balance out of range" TO WS-ERROR-MSG(WS-ERROR-COUNT)
       DISPLAY "Customer balance validation: FAIL"
    END-IF.
 
VALIDATE-TRANSACTION-DATE.
    ADD 1 TO WS-VALIDATION-COUNT
    
    IF WS-TRANSACTION-DATE >= 19000101 AND WS-TRANSACTION-DATE <= 20991231
       DISPLAY "Transaction date validation: PASS"
    ELSE
       SET SOME-VALIDATIONS-FAIL TO TRUE
       ADD 1 TO WS-ERROR-COUNT
       MOVE "Transaction date invalid" TO WS-ERROR-MSG(WS-ERROR-COUNT)
       DISPLAY "Transaction date validation: FAIL"
    END-IF.
 
DISPLAY-VALIDATION-RESULTS.
    DISPLAY "=== Validation Results Summary ==="
    DISPLAY "Total validations performed: " WS-VALIDATION-COUNT
    DISPLAY "Errors encountered: " WS-ERROR-COUNT
    
    IF ALL-VALIDATIONS-PASS
       DISPLAY "Overall validation status: ALL TESTS PASSED"
    ELSE
       DISPLAY "Overall validation status: SOME TESTS FAILED"
       DISPLAY "Error details:"
       PERFORM VARYING WS-VALIDATION-COUNT FROM 1 BY 1
          UNTIL WS-VALIDATION-COUNT > WS-ERROR-COUNT
          DISPLAY "  " WS-VALIDATION-COUNT ": " WS-ERROR-MSG(WS-VALIDATION-COUNT)
       END-PERFORM
    END-IF.

Best Practices for Boundary Checking

Following best practices ensures effective boundary checking that prevents errors and maintains data integrity.

Design Principles

  • Validate all input data at program entry points
  • Use condition names to define valid ranges clearly
  • Implement comprehensive error handling and reporting
  • Check boundaries before performing operations
  • Document all validation rules and constraints

Implementation Guidelines

  • Use consistent validation patterns throughout the program
  • Provide meaningful error messages for boundary violations
  • Implement graceful error recovery procedures
  • Log boundary violations for monitoring and analysis
  • Test all boundary conditions thoroughly

Performance Considerations

  • Optimize validation logic for performance-critical sections
  • Use efficient boundary checking algorithms
  • Minimize redundant validation operations
  • Consider caching validation results where appropriate
  • Profile validation performance in production environments

FAQ

What is boundary checking in COBOL?

Boundary checking in COBOL refers to validating that data values fall within acceptable ranges or limits. It prevents errors caused by data that exceeds expected boundaries, such as array indices, numeric ranges, or field lengths.

Why is boundary checking important in COBOL programs?

Boundary checking is crucial for preventing runtime errors, data corruption, and security vulnerabilities. It ensures data integrity, prevents buffer overflows, validates input data, and maintains program stability in production environments.

How do you implement boundary checking in COBOL?

Boundary checking is implemented using IF statements to validate ranges, checking array indices before access, validating field lengths, testing numeric limits, and using condition names to define acceptable ranges.

What are common boundary checking techniques in COBOL?

Common techniques include range validation with IF statements, array bounds checking, field length validation, numeric limit testing, date range validation, and using 88-level condition names to define valid ranges.

How do you handle boundary checking errors in COBOL?

Boundary checking errors are handled through comprehensive error checking, meaningful error messages, graceful error recovery, logging of boundary violations, and implementing fallback procedures for invalid data.

Error Handling

Comprehensive error handling strategies in COBOL

Data Validation

Input validation and data integrity techniques

Condition Names

Using condition names for range validation

Boolean Logic

Logical operations for boundary testing