1. IF .. RS/RI .. always returns False. Example, IF Testing RI ING returns T under 4.2.a, F under unicode. Tested with Unicode and Raw fields, same result. * FIXED * Tested ok with April 24 engine.

NOTE: The RI and RS operators do not function as described in the previous paragraph. Instead, the pattern and the search string are both converted to UTF-32 (if necessary) and the regular expression is evaluated in Unicode form (KAD).

1. Does not give transcode error as expected. The specs say National/Unicode fields should be transcoded down to 8859-1 first. Or does this mean Regular Expressions will work with Unicode, and don't have to be transcoded? ** Correct, RS/RI should work with Unicode fields (but don't, see #7 above).

1. The EX operator gives the same result as IN, ie, IF ... IN ... and IF ... EX .... both return true when used with Unicode fields. Use 'testing' for LHS and 'ing' for RHS. Seems to work ok with single character operands.* FIXED * April 5 engine
2. The EX operator gives the same result as IN, ie, IF ... IN ... and IF ... EX .... both return true when used with National fields. Use 'testing' for LHS and 'ing' for RHS. Seems to work ok with single character operands.* FIXED * April 5 engine
3. Compiler does not flag Group field to Unicode comparison as an error * FIXED * April 5 engine
4. Compiler does not flag Group field to National comparison as an error * FIXED * April 5 engine
5. Executing an IF .. RS/RI with Unicode or National fields causes process to abort. 2nd attempt causes session to crash. *FIXED * April 5 engine

1. IF .. RS/RI .. always returns False. Example, IF Testing RI ING returns T under 4.2.a, F under unicode. Tested with Unicode and Raw fields, same result.
2. Does not give transcode error as expected. The specs say National/Unicode fields should be transcoded down to 8859-1 first. Or does this mean Regular Expressions will work with Unicode, and don't have to be transcoded?
3. 
   

1. The EX operator gives the same result as IN, ie, IF ... IN ... and IF ... EX .... both return true when used with National fields. Use 'testing' for LHS and 'ing' for RHS. Seems to work ok with single character operands.
2. Compiler does not flag Group field to Unicode comparison as an error
3. Compiler does not flag Group field to National comparison as an error
4. Executing an IF .. RS/RI with Unicode or National fields causes process to abort. 2nd attempt causes session to crash.
5. Not sure if this is a bug or not: If I compare 2 raw alphas, then 'a' is GT 'A', as per the ASCII table. If I compare raw 'a' to Unicode 'A', then the opposite is true. It this because the raw was transcoded to unicode, and then the Unicode collating sequence was used, which puts the lower case before the upper case?

1. The EX operator gives the same result as IN, ie, IF ... IN ... and IF ... EX .... both return true when used with Unicode fields. Use 'testing' for LHS and 'ing' for RHS. Seems to work ok with single character operands.

1. Comparing Raw alpha fields, says 1 is LE 2. 1 is LT 2, not LE 2.
   

1. Unicode to Literal, same as 8,9,10, reports LE/GE when should just be GT/LT. Comparing literal \u03A3 to U+0385, or comparing U+03a3 to 'Testing'.
2. National to Literal, same as 8,9,10, reports LE/GE when should be just GT/LT. Comparing National "A" to \u0024 ($), reports "A" is GE "$".
3. 
   

1. Test Unicode to Unicode comparisons
2. Test National to National comparisons
3. Test Unicode to National comparisons
4. Test National to Unicode comparisons
5. Test Unicode to Raw
6. Test Raw to Unicode
7. Test National to Raw
8. Test Raw to National
9. Test Unicode to Literal (\uxxx, \UXXXXXXXX, normal)

1. Unicode to Literal, same as 8,9,10, reports LE/GE when should just be GT/LT. Comparing literal \u03A3 to U+0385, or comparing U+03a3 to 'Testing'.
   

1. The EX operator gives the same result as IN, ie, IF ... IN ... and IF ... EX .... both return true when used with Unicode fields. Use 'testing' for LHS and 'ing' for RHS. Seems to work ok with single character operands.
2. The EX operator gives the same result as IN, ie, IF ... IN ... and IF ... EX .... both return true when used with National fields. Use 'testing' for LHS and 'ing' for RHS. Seems to work ok with single character operands.

1. Executing an IF .. RS/RI with Unicode or National fields causes process to abort. 2nd attempt causes session to crash.
2. When comparing Unicode character 'Ó' (U+04E7) to National string 'ing', GE returns True.
3. Not sure if this is a bug or not: If I compare 2 raw alphas, then 'a' is GT 'A', as per the ASCII table. If I compare raw 'a' to Unicode 'A', then the opposite is true. It this because the raw was transcoded to unicode, and then the Unicode collating sequence was used, which puts the lower case before the upper case?
4. Unicode 'B' is GE raw 'A'. Wrong, it's GT, but not GE. Same problem if you reverse Unicode & Raw operands.
5. Unicode 'A' is LE raw 'B'. Wrong, it's LT, but not LE. Same problem if you reverse Unicode & Raw operands.
6. National Fields have the same problems as 8 & 9, report LE/GE as true when it's only LT/GT.
7. Unicode to Literal, same as 8,9,10, reports LE/GE when should just be GT/LT. Comparing literal \u03A3 to U+0385
   

1. When comparing Unicode character 'Ó§' (U+04E7) to National string 'ing', GE returns True. Is that correct??

1. Test RI/RS if they give transcode error when transcoding UTF-8 to RAW

1. The EX operator gives the same result as IN, ie, IF ... IN ... and IF ... EX .... both return true when used with National fields.

1. IF .. RS/RI causes process to abort. 2nd run causes session to crash

1. Test if the ILF Editor allows all valid combinates from the above list
2. Test if the ILF Editor give a meaningful error when entering invalid combinations
3. Test if the Process Compiler allows all valid combinates from the above list
4. Test if the Process Compiler give a meaningful error when encountering invalid combinations.
5. Test Raw to Raw comparisons to ensure they aren't affected
6. Test Unicode/National to Group and vice versa for compile errors
7. Test Unicode/National to Unicode/National
8. Test Unicode/National to Raw
9. Test Unicode/National to Literals

Bugs

1. The EX operator gives the same result as IN, ie, IF ... IN ... and IF ... EX .... both return true when used with Unicode fields.
2. Compiler does not flag Group field to Unicode comparison as an error
3. Compiler does not flag Group field to National comparison as an error

IF / AND / OR Statements

• • The operation is performed by comparing 4-byte UTF-32 characters.

• • The operation is performed by comparing 4-byte UTF-32 characters.

• • The operation is performed by comparing 4-byte UTF-32 characters.
• UNICODE or NATIONAL alpha compared with a Group field (or Group compared with UNICODE or NATIONAL)

Test Plan

SET TEMP Statement

Overview

<-- @page { margin: 0.79in } P { margin-bottom: 0.08in } -->

The GE/GT/LE/LT operators should use the Unicode collation API when UTF-32 operands are involved. This is because the 32-bit values that represent UTF-32 characters may not necessarily correspond to the expected collating sequence.

The RI/SI operators expect that the operands will be 8-bit RAW Alpha characters. If UTF-32 operands are specified in conjunction with these operators, they will need to be transcoded to the 8859-1 encoding used by a RAW Alpha field before the statement can be executed. If any character values are encountered that cannot be represented by an 8859-1 encoding, a data exception should occur.

The following applies to all operators other than RS/RI:

• RAW alpha or Group compared with RAW Alpha, Group, or Literal:
  • This is the existing condition and no charges have been made.
• UNICODE or NATIONAL alpha compared with UNICODE or NATIONAL alpha:
  • If there is a mismatch in field lengths then the shorter is padded with UTF-32 space to match the length of the longer field.
  • The poeration is performed by comparing 4-byte UTF-32 characters.
• UNICODE or NATIONAL alpha compared with RAW alpha (or RAW compared to UNICODE or NATIONAL):
  • The RAW operand is transcoded to UTF-32 characters.
  • If there is a mismatch in field lengths then the shorter is padded with UTF-32 space to match the length of the longer field.
  • The poeration is performed by comparing 4-byte UTF-32 characters.
• UNICODE or NATIONAL alpha compared with a Literal
  • The literal operand is considered to be a RAW alpha so transcoding from 8859-15 to UTF-32 will take place before the comparison.
  • If the literal contains unicode escape sequences (\u#### or \U########) they will be honored.
  • The literal "_" will still be honored as a way to search for a trailing space.
  • If there is a mismatch in field lengths then the shorter is padded with UTF-32 space to match the length of the longer field.
  • The poeration is performed by comparing 4-byte UTF-32 characters.
• UNICODE or NATIONAL alpha compared with a Group field (or Group compared with UNMICODE or NATIONAL)
  • This combination is not supported.
  • The process compiler should report this as an error.
  • Since many --- Alphafields are redefined to be UNICODE this will likely break some applications.

Test Plan

ILF Editor: (untested)

Test Requirements:

Does the ILF Editor allow all valid combinates from the above list?

Does the ILF Editor give a meaningful error when entering invalid combinations?

Test Results and Notes:

Untested

Process Compiler: (untested)

Test Requirements:

Does the Process Compiler allow all valid combinates from the above list?

Does the Process Compiler give a meaningful error when encountering invalid combinations? (can use Opt-88 to force saving or errors)

Test Results and Notes:

Untested

Bugs