## QT3TS Conformance Summary - Operators

| Tests | Passed | Skipped |
| --- | --- | --- |
| 4366 | 3544 | 822 |

## Ignore Reasons

The following table gives an overview of all reasons to exclude one of the bellow listed test cases from being executed. The reasons are referanced bellow by there *Reason Code*.

| Reason Code | Description | Number of Ignored Tests |
| --- | --- | --- |
| `OTH-MEM` | Java heap size problems | 1 |
| `SHE-XSD` | Schema-awareness is not supported by Saxon-HE | 64 |
| `RES-XP3-1` | The XPath engine supports only XPath 3.1. | 798 |



## Ignored Test Cases

The following table lists all test case (of the given test group) that are marked as pending. The reason are referenced by a reason code which can be looked up in the table above.

| Test-ID | Description | Ignore Reason Code |
| --- | --- | --- |
| `nodeexpression46` | Test of a ComparisonExpression with the operands set as follows operand1 = Sequence of single Element Node operator = >> operand2 = Single Element Constructor | RES-XP3-1 |
| `cbcl-node-after-001` | test node after operator | RES-XP3-1 |
| `cbcl-node-after-002` | test node after operator | RES-XP3-1 |
| `nodeexpression18` | Test of a ComparisonExpression with the operands set as follows operand1 = empty Sequence operator = << operand2 = Single Element Constructor | RES-XP3-1 |
| `nodeexpression21` | Test of a ComparisonExpression with the operands set as follows operand1 = Single Element Constructor operator = << operand2 = empty Sequence | RES-XP3-1 |
| `nodeexpression22` | Test of a ComparisonExpression with the operands set as follows operand1 = Single Element Constructor operator = << operand2 = Single Element Constructor | RES-XP3-1 |
| `nodeexpression23` | Test of a ComparisonExpression with the operands set as follows operand1 = Single Element Constructor operator = << operand2 = Single Node Element | RES-XP3-1 |
| `nodeexpression24` | Test of a ComparisonExpression with the operands set as follows operand1 = Single Element Constructor operator = << operand2 = Sequence of single Element Node | RES-XP3-1 |
| `nodeexpression26` | Test of a ComparisonExpression with the operands set as follows operand1 = Single Node Element operator = << operand2 = Single Element Constructor | RES-XP3-1 |
| `nodeexpression30` | Test of a ComparisonExpression with the operands set as follows operand1 = Sequence of single Element Node operator = << operand2 = Single Element Constructor | RES-XP3-1 |
| `K-NodeBefore-12` | Saxon bug 3384, see https://saxonica.plan.io/issues/3384 | RES-XP3-1 |
| `cbcl-node-before-001` | test node before operator | RES-XP3-1 |
| `cbcl-node-before-002` | test node before operator | RES-XP3-1 |
| `Comp-notation-1` | notation comparison | RES-XP3-1, SHE-XSD, SHE-XSD |
| `Comp-notation-2` | notation comparison | RES-XP3-1, SHE-XSD, SHE-XSD |
| `Comp-notation-3` | notation comparison | RES-XP3-1, SHE-XSD, SHE-XSD |
| `Comp-notation-4` | notation comparison using "ne" | RES-XP3-1, SHE-XSD, SHE-XSD |
| `Comp-notation-5` | notation comparison using "ne" | RES-XP3-1, SHE-XSD, SHE-XSD |
| `Comp-notation-6` | notation comparison using "ne" | RES-XP3-1, SHE-XSD, SHE-XSD |
| `Comp-notation-7` | Evaluation of Notation Comparison operator (eq) and used expression as argument to fn:not function, returns false. | RES-XP3-1, SHE-XSD, SHE-XSD |
| `Comp-notation-8` | Evaluation of Notation Comparison operator (eq) and used expression as argument to fn:not function, returns true | RES-XP3-1, SHE-XSD, SHE-XSD |
| `Comp-notation-9` | Evaluation of Notation Comparison operator (ne) and used expression as argument to fn:not function, returns true. | RES-XP3-1, SHE-XSD, SHE-XSD |
| `Comp-notation-10` | Evaluation of Notation Comparison operator (ne) and used expression as argument to fn:not function, returns false. | RES-XP3-1, SHE-XSD, SHE-XSD |
| `Comp-notation-11` | Evaluation of Notation Comparison operator (eq) and used expression as argument to fn:boolean function. | RES-XP3-1, SHE-XSD, SHE-XSD |
| `Comp-notation-12` | Evaluation of Notation Comparison operator (ne) and used expression as argument to fn:boolean function. | RES-XP3-1, SHE-XSD, SHE-XSD |
| `Comp-notation-13` | Evaluation of Notation Comparison operator (eq) and used in boolean expression with "fn:true" and "and" . | RES-XP3-1, SHE-XSD, SHE-XSD |
| `Comp-notation-14` | Evaluation of Notation Comparison operator (ne) and used in boolean expression with "fn:true" and "and" . | RES-XP3-1, SHE-XSD, SHE-XSD |
| `Comp-notation-15` | Evaluation of Notation Comparison operator (eq) and used in boolean expression with "fn:true" and "or" . | RES-XP3-1, SHE-XSD, SHE-XSD |
| `Comp-notation-16` | Evaluation of Notation Comparison operator (ne) and used in boolean expression with "fn:true" and "or" . | RES-XP3-1, SHE-XSD, SHE-XSD |
| `Comp-notation-17` | Evaluation of Notation Comparison operator (eq) and used in boolean expression with "fn:false" and "and" . | RES-XP3-1, SHE-XSD, SHE-XSD |
| `Comp-notation-18` | Evaluation of Notation Comparison operator (ne) and used in boolean expression with "fn:false" and "and" . | RES-XP3-1, SHE-XSD, SHE-XSD |
| `Comp-notation-19` | Evaluation of Notation Comparison operator (eq) and used in boolean expression with "fn:false" and "or" . | RES-XP3-1, SHE-XSD, SHE-XSD |
| `Comp-notation-20` | Evaluation of Notation Comparison operator (ne) and used in boolean expression with "fn:false" and "or" . | RES-XP3-1, SHE-XSD, SHE-XSD |
| `Comp-notation-21` | Evaluation of expression of Notation Comparison operator (eq) used as argument to "fn:string" function. | RES-XP3-1, SHE-XSD, SHE-XSD |
| `Comp-notation-22` | Evaluation of expression of Notation Comparison operator (ne) used as argument to "fn:string" function. | RES-XP3-1, SHE-XSD, SHE-XSD |
| `op-numeric-addmix2args-4` | Simple addition test, second operator is a node, atomization applied | RES-XP3-1 |
| `op-numeric-addmix2args-5` | Simple addition test, second operator is a node, atomization applied | RES-XP3-1 |
| `op-numeric-addmix2args-6` | Simple addition test, second operator node which is not atomizable | RES-XP3-1 |
| `op-numeric-addmix2args-7` | Simple addition test, two operands are nodes | RES-XP3-1 |
| `op-numeric-addmix2args-8` | Simple addition test, second operator is a node, atomizable but not castable to integer | RES-XP3-1 |
| `op-numeric-addmix2args-9` | Simple addition test pass an empty node for second operator | RES-XP3-1 |
| `K2-NumericAdd-2` | Arithmetics where the operands are directly constructed nodes. | RES-XP3-1 |
| `K2-NumericAdd-3` | Arithmetics where the operands are directly constructed attributes. | RES-XP3-1 |
| `op-numeric-add-1` | Check dynamic type of numeric add on arguments of union of numeric types and untypedAtomic. | RES-XP3-1 |
| `op-numeric-add-2` | Numeric addition on schema-validated input. | RES-XP3-1, SHE-XSD |
| `op-numeric-add-3` | Numeric addition on schema-validated input. | RES-XP3-1, SHE-XSD |
| `op-numeric-add-4` | Numeric addition on schema-validated input. | RES-XP3-1, SHE-XSD |
| `op-numeric-add-5` | Numeric addition on schema-validated input. | RES-XP3-1, SHE-XSD |
| `op-numeric-add-6` | Numeric addition on schema-validated input. | RES-XP3-1, SHE-XSD |
| `op-numeric-add-7` | Numeric addition on schema-validated input. | RES-XP3-1, SHE-XSD |
| `op-numeric-add-8` | Numeric addition on schema-validated input. | RES-XP3-1, SHE-XSD |
| `op-numeric-add-9` | Numeric addition on schema-validated input. | RES-XP3-1, SHE-XSD |
| `op-numeric-add-10` | Numeric addition on schema-validated input. | RES-XP3-1, SHE-XSD |
| `op-numeric-add-11` | Numeric addition on schema-validated input. | RES-XP3-1, SHE-XSD |
| `op-numeric-add-12` | Numeric addition on schema-validated input. | RES-XP3-1, SHE-XSD |
| `op-numeric-add-13` | Numeric addition on schema-validated input with user-defined types. | RES-XP3-1, SHE-XSD |
| `op-numeric-add-14` | Numeric addition on schema-validated input with union types. | RES-XP3-1, SHE-XSD |
| `op-numeric-add-15` | Numeric addition on schema-validated input with union types. | RES-XP3-1, SHE-XSD |
| `op-numeric-add-16` | Numeric addition on schema-validated input with union types. | RES-XP3-1, SHE-XSD |
| `K2-NumericEqual-1` | Compare an xs:integer to a processing instuction node. | RES-XP3-1 |
| `K2-NumericEqual-2` | Compare an xs:integer to a processing instuction node(#2). | RES-XP3-1 |
| `K2-NumericEqual-3` | Compare an xs:integer to a comment. | RES-XP3-1 |
| `K2-NumericEqual-4` | Compare an xs:integer to a comment(#2). | RES-XP3-1 |
| `K2-NumericEqual-5` | Compare an xs:integer to a text node. | RES-XP3-1 |
| `K2-NumericEqual-6` | Compare an xs:integer to a text node(#2). | RES-XP3-1 |
| `cbcl-numeric-equal-001` | test comparison of xs:double | RES-XP3-1 |
| `cbcl-numeric-equal-002` | test comparison of xs:float | RES-XP3-1 |
| `cbcl-numeric-equal-003` | test comparison of xs:decimal | RES-XP3-1 |
| `cbcl-numeric-equal-004` | test comparison of xs:integer | RES-XP3-1 |
| `cbcl-numeric-equal-005` | test comparison of xs:double | RES-XP3-1 |
| `cbcl-numeric-equal-006` | test comparison of xs:float | RES-XP3-1 |
| `cbcl-numeric-equal-007` | test comparison of xs:decimal | RES-XP3-1 |
| `cbcl-numeric-equal-008` | test comparison of xs:integer | RES-XP3-1 |
| `cbcl-numeric-equal-009` | test comparison | RES-XP3-1 |
| `cbcl-numeric-equal-010` | test comparison | RES-XP3-1 |
| `cbcl-numeric-equal-011` | test comparison | RES-XP3-1 |
| `cbcl-numeric-equal-012` | test comparison | RES-XP3-1 |
| `cbcl-numeric-equal-013` | test comparison | RES-XP3-1 |
| `cbcl-numeric-equal-014` | test comparison | RES-XP3-1 |
| `cbcl-numeric-equal-015` | test comparison | RES-XP3-1 |
| `cbcl-numeric-equal-016` | test comparison | RES-XP3-1 |
| `cbcl-numeric-equal-017` | test comparison | RES-XP3-1 |
| `cbcl-numeric-equal-018` | test comparison | RES-XP3-1 |
| `op-numeric-dividemix2args-4` | Simple division test, second operator is a node, atomization applied | RES-XP3-1 |
| `op-numeric-dividemix2args-5` | Simple division test, second operator is a node, atomization applied | RES-XP3-1 |
| `op-numeric-dividemix2args-6` | Simple division test, second operator node which is not atomizable | RES-XP3-1 |
| `op-numeric-dividemix2args-7` | Simple division test, two operands are nodes | RES-XP3-1 |
| `op-numeric-dividemix2args-8` | Simple division test, second operator is a node, atomizable but not castable to integer | RES-XP3-1 |
| `op-numeric-dividemix2args-9` | Simple division test pass an empty node for second operator | RES-XP3-1 |
| `K2-NumericDivide-17` | Ensure the 'div' keyword is parsed correctly. | RES-XP3-1 |
| `cbcl-numeric-divide-001` | test division of xs:double NaN | RES-XP3-1 |
| `cbcl-numeric-divide-002` | test division by xs:double NaN | RES-XP3-1 |
| `cbcl-numeric-divide-003` | test division by xs:double 1 | RES-XP3-1 |
| `cbcl-numeric-divide-004` | test division by xs:double -1 | RES-XP3-1 |
| `cbcl-numeric-divide-005` | test division of xs:float NaN | RES-XP3-1 |
| `cbcl-numeric-divide-006` | test division by xs:float NaN | RES-XP3-1 |
| `cbcl-numeric-divide-007` | test division by xs:float 1 | RES-XP3-1 |
| `cbcl-numeric-divide-008` | test division by xs:float -1 | RES-XP3-1 |
| `cbcl-numeric-divide-009` | test division by xs:decimal 0 | RES-XP3-1 |
| `cbcl-numeric-divide-010` | test division by xs:decimal 1 | RES-XP3-1 |
| `cbcl-numeric-divide-011` | test division by xs:decimal -1 | RES-XP3-1 |
| `cbcl-numeric-divide-012` | test division by xs:integer 0 | RES-XP3-1 |
| `cbcl-numeric-divide-013` | test division by xs:integer 1 | RES-XP3-1 |
| `cbcl-numeric-divide-014` | test division by xs:integer -1 | RES-XP3-1 |
| `cbcl-numeric-greater-than-001` | test comparison of xs:double | RES-XP3-1 |
| `cbcl-numeric-greater-than-002` | test comparison of xs:float | RES-XP3-1 |
| `cbcl-numeric-greater-than-003` | test comparison of xs:decimal | RES-XP3-1 |
| `cbcl-numeric-greater-than-004` | test comparison of xs:integer | RES-XP3-1 |
| `cbcl-numeric-greater-than-005` | test comparison of xs:double | RES-XP3-1 |
| `cbcl-numeric-greater-than-006` | test comparison of xs:float | RES-XP3-1 |
| `cbcl-numeric-greater-than-007` | test comparison of xs:decimal | RES-XP3-1 |
| `cbcl-numeric-greater-than-008` | test comparison of xs:integer | RES-XP3-1 |
| `cbcl-numeric-greater-than-009` | test comparison of xs:double | RES-XP3-1 |
| `cbcl-numeric-greater-than-010` | test comparison of xs:float | RES-XP3-1 |
| `cbcl-numeric-greater-than-011` | test comparison of xs:double | RES-XP3-1 |
| `cbcl-numeric-greater-than-012` | test comparison of xs:float | RES-XP3-1 |
| `cbcl-numeric-greater-than-013` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-greater-than-014` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-greater-than-015` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-greater-than-016` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-greater-than-017` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-greater-than-018` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-greater-than-019` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-greater-than-020` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-greater-than-021` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-greater-than-022` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-greater-than-023` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-greater-than-024` | test comparison of integers | RES-XP3-1 |
| `numeric-greater-than-101` | test comparison of number to untypedAtomic including whitespace | RES-XP3-1 |
| `numeric-greater-than-102` | test comparison of number to untypedAtomic including whitespace | RES-XP3-1 |
| `op-numeric-integer-dividemix2args-4` | Simple integer division test, second operator is a node, atomization applied | RES-XP3-1 |
| `op-numeric-integer-dividemix2args-5` | Simple integer division test, second operator is a node, atomization applied | RES-XP3-1 |
| `op-numeric-integer-dividemix2args-6` | Simple integer division test, second operator node which is not atomizable | RES-XP3-1 |
| `op-numeric-integer-dividemix2args-7` | Simple integer division test, two operands are nodes | RES-XP3-1 |
| `op-numeric-integer-dividemix2args-8` | Simple integer division test, second operator is a node, atomizable but not castable to integer | RES-XP3-1 |
| `op-numeric-integer-dividemix2args-9` | Simple integer division test pass an empty node for second operator | RES-XP3-1 |
| `cbcl-numeric-idivide-001` | test possible overflow of xs:decimal | RES-XP3-1 |
| `cbcl-numeric-idivide-002` | test possible overflow of xs:double | RES-XP3-1 |
| `cbcl-numeric-idivide-003` | test possible overflow of xs:float | RES-XP3-1 |
| `cbcl-numeric-idivide-004` | ensure that idividing xs:integers returns an xs:integer | RES-XP3-1 |
| `cbcl-numeric-idivide-009` | Test numeric idiv with a potential type check error | RES-XP3-1 |
| `cbcl-numeric-less-than-001` | test comparison of xs:double | RES-XP3-1 |
| `cbcl-numeric-less-than-002` | test comparison of xs:float | RES-XP3-1 |
| `cbcl-numeric-less-than-003` | test comparison of xs:decimal | RES-XP3-1 |
| `cbcl-numeric-less-than-004` | test comparison of xs:integer | RES-XP3-1 |
| `cbcl-numeric-less-than-005` | test comparison of xs:double | RES-XP3-1 |
| `cbcl-numeric-less-than-006` | test comparison of xs:float | RES-XP3-1 |
| `cbcl-numeric-less-than-007` | test comparison of xs:decimal | RES-XP3-1 |
| `cbcl-numeric-less-than-008` | test comparison of xs:integer | RES-XP3-1 |
| `cbcl-numeric-less-than-009` | test comparison of xs:double | RES-XP3-1 |
| `cbcl-numeric-less-than-010` | test comparison of xs:float | RES-XP3-1 |
| `cbcl-numeric-less-than-011` | test comparison of xs:double | RES-XP3-1 |
| `cbcl-numeric-less-than-012` | test comparison of xs:float | RES-XP3-1 |
| `cbcl-numeric-less-than-013` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-less-than-014` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-less-than-015` | test comparison of integers | RES-XP3-1 |
| `cbcl-time-less-than-001` | test comparison of time | RES-XP3-1 |
| `cbcl-time-less-than-006` | test comparison of time | RES-XP3-1 |
| `cbcl-time-less-than-011` | test comparison of time | RES-XP3-1 |
| `cbcl-time-less-than-012` | test comparison of time | RES-XP3-1 |
| `cbcl-time-less-than-013` | test comparison of time | RES-XP3-1 |
| `cbcl-time-less-than-014` | test comparison of time | RES-XP3-1 |
| `K2-RangeExpr-4` | Expressions that are tricky for local rewrites. | RES-XP3-1 |
| `RangeExpr-409d` | multiple range, very large numbers | OTH-MEM |
| `RangeExpr-604` | atomized first arg | RES-XP3-1 |
| `fn-union-node-args-015` | arg: node and node | SHE-XSD |
| `fn-union-node-args-016` | arg: node & node | SHE-XSD |
| `fn-union-node-args-017` | arg: node & node | SHE-XSD |
| `fn-union-node-args-018` | arg: text node & text node | SHE-XSD |
| `fn-union-node-args-019` | arg: text node & text node | SHE-XSD |
| `fn-union-node-args-020` | arg: text node & text node | SHE-XSD |
| `fn-union-node-args-021` | arg: text node & text node | SHE-XSD |
| `fn-union-node-args-022` | arg: text node & text node | SHE-XSD |
| `K2-SeqUnion-1` | Ensure nodes are deduplicated and sorted even though one of the operands is the empty sequence. | RES-XP3-1 |
| `K2-SeqUnion-2` | Ensure nodes are deduplicated and sorted even though one of the operands is the empty sequence(#2). | RES-XP3-1 |
| `K2-SeqUnion-3` | Use 'comment' as right operand. | RES-XP3-1 |
| `K2-SeqUnion-4` | Ensure node deduplication is done on the operands. | RES-XP3-1 |
| `K2-SeqUnion-6` | Use a node kind keyword, text, to test query parsing. | RES-XP3-1 |
| `K2-SeqUnion-7` | Use a node kind keyword, node, to test query parsing. | RES-XP3-1 |
| `K2-SeqUnion-8` | Use a node kind keyword, element, to test query parsing. | RES-XP3-1 |
| `K2-SeqUnion-9` | Use a node kind keyword, attribute, to test query parsing. | RES-XP3-1 |
| `K2-SeqUnion-10` | Use a node kind keyword, document-node, to test query parsing. | RES-XP3-1 |
| `K2-SeqUnion-11` | Use a node kind keyword, comment, to test query parsing. | RES-XP3-1 |
| `K2-SeqUnion-12` | Use a node kind keyword, processing-instruction, to test query parsing. | RES-XP3-1 |
| `K2-SeqUnion-13` | Use a node kind keyword, item, to test query parsing. | RES-XP3-1 |
| `K2-SeqUnion-14` | Use a node kind keyword, document, to test query parsing. | RES-XP3-1 |
| `K2-SeqUnion-15` | Use a node kind keyword, if, to test query parsing. | RES-XP3-1 |
| `K2-SeqUnion-16` | Use a node kind keyword, then, to test query parsing. | RES-XP3-1 |
| `K2-SeqUnion-17` | Use a node kind keyword, mod, to test query parsing. | RES-XP3-1 |
| `K2-SeqUnion-18` | Use a node kind keyword, div, to test query parsing. | RES-XP3-1 |
| `K2-SeqUnion-19` | Use a node kind keyword, empty-sequence, to test query parsing. | RES-XP3-1 |
| `K2-SeqUnion-20` | Use a node kind keyword, schema-attribute, to test query parsing. | RES-XP3-1 |
| `K2-SeqUnion-21` | Use a node kind keyword, schema-element, to test query parsing. | RES-XP3-1 |
| `K2-SeqUnion-22` | Use a computed attribute constructor as right operand. | RES-XP3-1 |
| `K2-SeqUnion-23` | Use a computed attribute constructor as right operand(#2). | RES-XP3-1 |
| `K2-SeqUnion-24` | Use a computed attribute constructor as right operand. | RES-XP3-1 |
| `K2-SeqUnion-25` | Use an element constructor as right operand(#2). | RES-XP3-1 |
| `K2-SeqUnion-26` | Use a processing instruction constructor as right operand. | RES-XP3-1 |
| `K2-SeqUnion-27` | Use a processing instruction constructor as right operand. | RES-XP3-1 |
| `K2-SeqUnion-28` | Use a comment constructor as right operand. | RES-XP3-1 |
| `K2-SeqUnion-29` | Use a text node constructor as right operand. | RES-XP3-1 |
| `K2-SeqUnion-30` | Use a name test that resembles the descendant axis as right operand. | RES-XP3-1 |
| `K2-SeqUnion-31` | Use a name test that resembles the attribute axis as right operand. | RES-XP3-1 |
| `K2-SeqUnion-32` | Use a name test that resembles the self axis as right operand. | RES-XP3-1 |
| `K2-SeqUnion-33` | Use a name test that resembles the descendant-or-self axis as right operand. | RES-XP3-1 |
| `K2-SeqUnion-34` | Use a name test that resembles the following-sibling axis as right operand. | RES-XP3-1 |
| `K2-SeqUnion-35` | Use a name test that resembles the following axis as right operand. | RES-XP3-1 |
| `K2-SeqUnion-36` | Use a name test that resembles the preceding-sibling axis as right operand. | RES-XP3-1 |
| `K2-SeqUnion-37` | Use a name test that resembles the preceding axis as right operand. | RES-XP3-1 |
| `K2-SeqUnion-38` | Use a name test that resembles the parent axis as right operand. | RES-XP3-1 |
| `K2-SeqUnion-39` | Use a name test that resembles the ancestor axis as right operand. | RES-XP3-1 |
| `K2-SeqUnion-40` | Use a name test that resembles the ancestor axis as right operand. | RES-XP3-1 |
| `K2-SeqUnion-41` | Use a name test that resembles the ancestor-or-self axis as right operand. | RES-XP3-1 |
| `K2-SeqUnion-42` | Use 'declare as right operand. | RES-XP3-1 |
| `K2-SeqUnion-45` | Explicitly sort the result of a union expression. | RES-XP3-1 |
| `combiningnodeseqhc1` | Simple combination of node sequences involving integers. uses "\|" operator | RES-XP3-1 |
| `combiningnodeseqhc2` | Simple combination of node sequences involving integers. uses "union" operator | RES-XP3-1 |
| `combiningnodeseqhc3` | Simple combination of node sequences involving integers and repetition. uses "\|" operator | RES-XP3-1 |
| `combiningnodeseqhc4` | Simple combination of node sequences involving integers and repetition. uses "union" operator | RES-XP3-1 |
| `combiningnodeseqhc5` | Simple combination of node sequences involving integers and the empty sequence. Uses "\|" operator | RES-XP3-1 |
| `combiningnodeseqhc6` | Simple combination of node sequences involving integers and the empty sequence. Uses "union" operator | RES-XP3-1 |
| `combiningnodeseqhc7` | Simple combination of node sequences involving different children of xml data source. Uses "\|" operator | RES-XP3-1 |
| `combiningnodeseqhc8` | Simple combination of node sequences involving xml data source. Uses "union" operator | RES-XP3-1 |
| `combiningnodeseqhc9` | Simple combination of node sequences involving multiple xml data sources. Uses "\|" operator | RES-XP3-1 |
| `combiningnodeseqhc10` | Simple combination of node sequences involving multiple xml data sources. Uses "union" operator | RES-XP3-1 |
| `cbcl-fn-union-001` | Tests various optimizations on op:union | RES-XP3-1 |
| `cbcl-fn-union-002` | Tests optimization of union of path expressions | RES-XP3-1 |
| `cbcl-yearMonthDuration-greater-than-001` | test comparison of xs:yearMonthDuration | RES-XP3-1 |
| `cbcl-yearMonthDuration-greater-than-002` | test comparison of xs:yearMonthDuration | RES-XP3-1 |
| `cbcl-yearMonthDuration-greater-than-003` | test comparison of xs:yearMonthDuration | RES-XP3-1 |
| `cbcl-yearMonthDuration-greater-than-004` | test comparison of xs:yearMonthDuration | RES-XP3-1 |
| `cbcl-yearMonthDuration-greater-than-005` | test comparison of xs:yearMonthDuration | RES-XP3-1 |
| `cbcl-yearMonthDuration-greater-than-006` | test comparison of xs:yearMonthDuration | RES-XP3-1 |
| `cbcl-yearMonthDuration-less-than-001` | test comparison of xs:yearMonthDuration | RES-XP3-1 |
| `cbcl-yearMonthDuration-less-than-002` | test comparison of xs:yearMonthDuration | RES-XP3-1 |
| `cbcl-yearMonthDuration-less-than-003` | test comparison of xs:yearMonthDuration | RES-XP3-1 |
| `cbcl-yearMonthDuration-less-than-004` | test comparison of xs:yearMonthDuration | RES-XP3-1 |
| `cbcl-yearMonthDuration-less-than-005` | test comparison of xs:yearMonthDuration | RES-XP3-1 |
| `cbcl-yearMonthDuration-less-than-006` | test comparison of xs:yearMonthDuration | RES-XP3-1 |
| `same-key-002` | op:same-key should not use the default collation | RES-XP3-1 |
| `same-key-006` | op:same-key over numerics | RES-XP3-1 |
| `same-key-010` | op:same-key over numerics | RES-XP3-1 |
| `same-key-011` | op:same-key over numerics | RES-XP3-1 |
| `same-key-012` | op:same-key over numerics | RES-XP3-1 |
| `same-key-013` | op:same-key values with timezones | RES-XP3-1 |
| `same-key-014` | op:same-key values with timezones | RES-XP3-1 |
| `same-key-015` | op:same-key values with timezones | RES-XP3-1 |
| `same-key-016` | op:same-key values with timezones | RES-XP3-1 |
| `same-key-017` | op:same-key values with timezones | RES-XP3-1 |
| `same-key-018` | op:same-key values with timezones | RES-XP3-1 |
| `same-key-019` | op:same-key values with timezones | RES-XP3-1 |
| `same-key-020` | op:same-key values with timezones | RES-XP3-1 |
| `same-key-023` | op:same-key over strings. | RES-XP3-1 |
| `same-key-024` | op:same-key over strings and numeric. | RES-XP3-1 |
| `same-key-025` | op:same-key over numeric values. | RES-XP3-1 |
| `same-key-026` | op:same-key over numeric values. | RES-XP3-1 |
| `cbcl-dayTimeDuration-greater-than-001` | test comparison of dayTimeDurations | RES-XP3-1 |
| `cbcl-dayTimeDuration-greater-than-002` | test comparison of dayTimeDurations | RES-XP3-1 |
| `cbcl-dayTimeDuration-greater-than-003` | test comparison of xs:dayTimeDuration | RES-XP3-1 |
| `cbcl-dayTimeDuration-greater-than-004` | test comparison of xs:dayTimeDuration | RES-XP3-1 |
| `cbcl-dayTimeDuration-greater-than-005` | test comparison of xs:dayTimeDuration | RES-XP3-1 |
| `cbcl-dayTimeDuration-greater-than-006` | test comparison of xs:dayTimeDuration | RES-XP3-1 |
| `cbcl-value-greater-equal-001` | Test behaviour of the overloaded greater equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-greater-equal-002` | Test behaviour of the overloaded greater equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-greater-equal-003` | Test behaviour of the overloaded greater equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-greater-equal-004` | Test behaviour of the overloaded greater equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-greater-equal-005` | Test behaviour of the overloaded greater equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-greater-equal-006` | Test behaviour of the overloaded greater equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-greater-equal-007` | Test behaviour of the overloaded greater equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-greater-equal-008` | Test behaviour of the overloaded greater equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-greater-equal-009` | Test behaviour of the overloaded greater equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-greater-equal-010` | Test behaviour of the overloaded greater equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-greater-equal-011` | Test behaviour of the overloaded greater equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-greater-equal-012` | Test behaviour of the overloaded greater equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-greater-than-001` | Test behaviour of the overloaded greater than value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-greater-than-002` | Test behaviour of the overloaded greater than value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-greater-than-003` | Test behaviour of the overloaded greater than value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-greater-than-004` | Test behaviour of the overloaded greater than value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-greater-than-005` | Test behaviour of the overloaded greater than value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-greater-than-006` | Test behaviour of the overloaded greater than value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-greater-than-007` | Test behaviour of the overloaded greater than value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-greater-than-008` | Test behaviour of the overloaded greater than value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-greater-than-009` | Test behaviour of the overloaded greater than value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-greater-than-010` | Test behaviour of the overloaded greater than value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-greater-than-011` | Test behaviour of the overloaded greater than value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-greater-than-012` | Test behaviour of the overloaded greater than value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-dayTimeDuration-less-than-001` | test comparison of dayTimeDurations | RES-XP3-1 |
| `cbcl-dayTimeDuration-less-than-002` | test comparison of dayTimeDurations | RES-XP3-1 |
| `cbcl-dayTimeDuration-less-than-003` | test comparison of xs:dayTimeDuration | RES-XP3-1 |
| `cbcl-dayTimeDuration-less-than-004` | test comparison of xs:dayTimeDuration | RES-XP3-1 |
| `cbcl-dayTimeDuration-less-than-005` | test comparison of xs:dayTimeDuration | RES-XP3-1 |
| `cbcl-dayTimeDuration-less-than-006` | test comparison of xs:dayTimeDuration | RES-XP3-1 |
| `cbcl-value-less-equal-001` | Test behaviour of the overloaded less equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-less-equal-002` | Test behaviour of the overloaded less equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-less-equal-003` | Test behaviour of the overloaded less equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-less-equal-004` | Test behaviour of the overloaded less equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-less-equal-005` | Test behaviour of the overloaded less equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-less-equal-006` | Test behaviour of the overloaded less equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-less-equal-007` | Test behaviour of the overloaded less equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-less-equal-008` | Test behaviour of the overloaded less equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-less-equal-009` | Test behaviour of the overloaded less equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-less-equal-010` | Test behaviour of the overloaded less equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-less-equal-011` | Test behaviour of the overloaded less equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-value-less-equal-012` | Test behaviour of the overloaded less equal value comparison operator when presented with an expression with static type xs:duration. | RES-XP3-1 |
| `cbcl-divide-dayTimeDuration-001` | test division of xs:dayTimeDuration by 0 | RES-XP3-1 |
| `cbcl-divide-dayTimeDuration-002` | test division of xs:dayTimeDuration by 1 | RES-XP3-1 |
| `cbcl-div-001` | Test behaviour of division operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-div-002` | Test behaviour of division operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-div-003` | Test behaviour of division operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-div-004` | Test behaviour of division operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-div-005` | Test behaviour of division operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-div-006` | Test behaviour of division operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-div-007` | Test behaviour of division operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-div-008` | Test behaviour of division operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-div-009` | Test behaviour of division operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-div-010` | Test behaviour of division operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-div-011` | Test behaviour of division operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-div-012` | Test behaviour of division operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-div-013` | Test behaviour of division operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-div-014` | Test behaviour of division operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-div-015` | Test behaviour of division operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-div-016` | Test behaviour of division operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-divide-yearMonthDuration-001` | test division of xs:yearMonthDuration by 0 | RES-XP3-1 |
| `cbcl-divide-yearMonthDuration-002` | test division of xs:yearMonthDuration by 1 | RES-XP3-1 |
| `cbcl-divide-yearMonthDuration-003` | test possible overflow in division of xs:yearMonthDuration | RES-XP3-1 |
| `cbcl-dayTimeDuration-equal-001` | test comparison of dayTimeDurations | RES-XP3-1 |
| `cbcl-dayTimeDuration-equal-002` | test comparison of dayTimeDurations | RES-XP3-1 |
| `cbcl-dayTimeDuration-equal-003` | test comparison of xs:dayTimeDuration | RES-XP3-1 |
| `cbcl-dayTimeDuration-equal-004` | test comparison of xs:dayTimeDuration | RES-XP3-1 |
| `cbcl-dayTimeDuration-equal-005` | test comparison of xs:dayTimeDuration | RES-XP3-1 |
| `cbcl-dayTimeDuration-equal-006` | test comparison of xs:dayTimeDuration | RES-XP3-1 |
| `cbcl-duration-equal-001` | test comparison of dayTimeDurations | RES-XP3-1 |
| `cbcl-duration-equal-002` | test comparison of dayTimeDurations | RES-XP3-1 |
| `cbcl-duration-equal-003` | test comparison of xs:duration | RES-XP3-1 |
| `cbcl-duration-equal-004` | test comparison of xs:duration | RES-XP3-1 |
| `cbcl-duration-equal-005` | test comparison of xs:duration | RES-XP3-1 |
| `cbcl-duration-equal-006` | test comparison of xs:duration | RES-XP3-1 |
| `cbcl-yearMonthDuration-equal-001` | test equality of xs:yearMonthDuration | RES-XP3-1 |
| `cbcl-yearMonthDuration-equal-002` | test equality of xs:yearMonthDuration | RES-XP3-1 |
| `fn-except-node-args-015` | arg: node and node | SHE-XSD |
| `fn-except-node-args-016` | arg: node & node | SHE-XSD |
| `fn-except-node-args-017` | arg: node & node | SHE-XSD |
| `fn-except-node-args-018` | arg: text node & text node | SHE-XSD |
| `fn-except-node-args-019` | arg: text node & text node | SHE-XSD |
| `fn-except-node-args-020` | arg: text node & text node | SHE-XSD |
| `fn-except-node-args-021` | arg: text node & text node | SHE-XSD |
| `K2-SeqExcept-2` | Use a node kind keyword, text, to test query parsing. | RES-XP3-1 |
| `K2-SeqExcept-3` | Use a node kind keyword, node, to test query parsing. | RES-XP3-1 |
| `K2-SeqExcept-4` | Use a node kind keyword, element, to test query parsing. | RES-XP3-1 |
| `K2-SeqExcept-5` | Use a node kind keyword, attribute, to test query parsing. | RES-XP3-1 |
| `K2-SeqExcept-6` | Use a node kind keyword, document-node, to test query parsing. | RES-XP3-1 |
| `K2-SeqExcept-7` | Use a node kind keyword, comment, to test query parsing. | RES-XP3-1 |
| `K2-SeqExcept-8` | Use a node kind keyword, processing-instruction, to test query parsing. | RES-XP3-1 |
| `K2-SeqExcept-9` | Use a node kind keyword, item, to test query parsing. | RES-XP3-1 |
| `K2-SeqExcept-10` | Use a node kind keyword, document, to test query parsing. | RES-XP3-1 |
| `K2-SeqExcept-11` | Use a node kind keyword, if, to test query parsing. | RES-XP3-1 |
| `K2-SeqExcept-12` | Use a node kind keyword, then, to test query parsing. | RES-XP3-1 |
| `K2-SeqExcept-13` | Use a node kind keyword, mod, to test query parsing. | RES-XP3-1 |
| `K2-SeqExcept-14` | Use a node kind keyword, div, to test query parsing. | RES-XP3-1 |
| `K2-SeqExcept-15` | Use a node kind keyword, empty-sequence, to test query parsing. | RES-XP3-1 |
| `K2-SeqExcept-16` | Use a node kind keyword, schema-attribute, to test query parsing. | RES-XP3-1 |
| `K2-SeqExcept-17` | Use a node kind keyword, schema-element, to test query parsing. | RES-XP3-1 |
| `K2-SeqExcept-18` | Use a computed attribute constructor as right operand. | RES-XP3-1 |
| `K2-SeqExcept-19` | Use a computed attribute constructor as right operand(#2). | RES-XP3-1 |
| `K2-SeqExcept-20` | Use a computed attribute constructor as right operand. | RES-XP3-1 |
| `K2-SeqExcept-21` | Use a computed attribute constructor as right operand(#2). | RES-XP3-1 |
| `K2-SeqExcept-22` | Use a computed attribute constructor as right operand. | RES-XP3-1 |
| `K2-SeqExcept-23` | Use a computed attribute constructor as right operand. | RES-XP3-1 |
| `K2-SeqExcept-24` | Use a computed attribute constructor as right operand. | RES-XP3-1 |
| `K2-SeqExcept-25` | Use a computed attribute constructor as right operand. | RES-XP3-1 |
| `K2-SeqExcept-26` | Use a name test that is the descendant axis as right operand. | RES-XP3-1 |
| `K2-SeqExcept-27` | Use a name test that is the attribute axis as right operand. | RES-XP3-1 |
| `K2-SeqExcept-28` | Use a name test that is the self axis as right operand. | RES-XP3-1 |
| `K2-SeqExcept-29` | Use a name test that is the descendant-or-self axis as right operand. | RES-XP3-1 |
| `K2-SeqExcept-30` | Use a name test that is the following-sibling axis as right operand. | RES-XP3-1 |
| `K2-SeqExcept-31` | Use a name test that is the following axis as right operand. | RES-XP3-1 |
| `K2-SeqExcept-32` | Use a name test that is the preceding-sibling axis as right operand. | RES-XP3-1 |
| `K2-SeqExcept-33` | Use a name test that is the preceding axis as right operand. | RES-XP3-1 |
| `K2-SeqExcept-34` | Use a name test that is the parent axis as right operand. | RES-XP3-1 |
| `K2-SeqExcept-35` | Use a name test that is the ancestor axis as right operand. | RES-XP3-1 |
| `K2-SeqExcept-36` | Use a name test that is the ancestor axis as right operand. | RES-XP3-1 |
| `K2-SeqExcept-37` | Use a name test that is the ancestor-or-self axis as right operand. | RES-XP3-1 |
| `K2-SeqExcept-38` | Use 'declare as right operand. | RES-XP3-1 |
| `K2-SeqExcept-40` | Explicitly sort the result of an except expression. | RES-XP3-1 |
| `K2-SeqExcept-41` | Compare two nodes from different trees. | RES-XP3-1 |
| `K2-SeqExcept-42` | Ensure node deduplication is done. | RES-XP3-1 |
| `combiningnodeseqexcepthc1` | Simple combination of node sequences involving node types with integer data. Use "except" operator. | RES-XP3-1 |
| `combiningnodeseqexcepthc2` | Simple combination of node sequences involving repetition of the same element data. Use "except" operator. | RES-XP3-1 |
| `combiningnodeseqexcepthc3` | Simple combination of node sequences involving the empty sequence. Use "except" operator. | RES-XP3-1 |
| `combiningnodeseqexcepthc4` | Simple combination of node sequences that evaluates to the empty sequence. Use "except" operator. Use count to avoid empty file. | RES-XP3-1 |
| `combiningnodeseqexcepthc5` | Simple combination of node sequences involving multiple xml data sources and repetition of a sequence. Use "except" operator. Use count to avoid empty file results | RES-XP3-1 |
| `combiningnodeseqexcepthc6` | Simple combination of node sequences involving multiple xml data sources. Use "except" operator. | RES-XP3-1 |
| `except-100` | Deduplicate a node sequence, retaining order. Saxon bug 5194. | RES-XP3-1 |
| `cbcl-gDay-equal-001` | test comparison of gDay | RES-XP3-1 |
| `cbcl-gDay-equal-006` | test comparison of gDay | RES-XP3-1 |
| `cbcl-gDay-equal-011` | test comparison of gDay | RES-XP3-1 |
| `cbcl-gDay-equal-012` | test comparison of gDay | RES-XP3-1 |
| `cbcl-gDay-equal-013` | test comparison of gDay | RES-XP3-1 |
| `cbcl-gDay-equal-014` | test comparison of gDay | RES-XP3-1 |
| `cbcl-gMonth-equal-001` | test comparison of gMonth | RES-XP3-1 |
| `cbcl-gMonth-equal-006` | test comparison of gMonth | RES-XP3-1 |
| `cbcl-gMonth-equal-011` | test comparison of gMonth | RES-XP3-1 |
| `cbcl-gMonth-equal-012` | test comparison of gMonth | RES-XP3-1 |
| `cbcl-gMonth-equal-013` | test comparison of gMonth | RES-XP3-1 |
| `cbcl-gMonth-equal-014` | test comparison of gMonth | RES-XP3-1 |
| `cbcl-gMonthDay-equal-001` | test comparison of gMonthDay | RES-XP3-1 |
| `cbcl-gMonthDay-equal-006` | test comparison of gMonthDay | RES-XP3-1 |
| `cbcl-gMonthDay-equal-011` | test comparison of gMonthDay | RES-XP3-1 |
| `cbcl-gMonthDay-equal-012` | test comparison of gMonthDay | RES-XP3-1 |
| `cbcl-gMonthDay-equal-013` | test comparison of gMonthDay | RES-XP3-1 |
| `cbcl-gMonthDay-equal-014` | test comparison of gMonthDay | RES-XP3-1 |
| `cbcl-gYear-equal-001` | test comparison of gYear | RES-XP3-1 |
| `cbcl-gYear-equal-006` | test comparison of gYear | RES-XP3-1 |
| `cbcl-gYear-equal-011` | test comparison of gYear | RES-XP3-1 |
| `cbcl-gYear-equal-012` | test comparison of gYear | RES-XP3-1 |
| `cbcl-gYear-equal-013` | test comparison of gYear | RES-XP3-1 |
| `cbcl-gYear-equal-014` | test comparison of gYear | RES-XP3-1 |
| `cbcl-gYearMonth-equal-001` | test comparison of gYearMonth | RES-XP3-1 |
| `cbcl-gYearMonth-equal-006` | test comparison of gYearMonth | RES-XP3-1 |
| `cbcl-gYearMonth-equal-011` | test comparison of gYearMonth | RES-XP3-1 |
| `cbcl-gYearMonth-equal-012` | test comparison of gYearMonth | RES-XP3-1 |
| `cbcl-gYearMonth-equal-013` | test comparison of gYearMonth | RES-XP3-1 |
| `cbcl-gYearMonth-equal-014` | test comparison of gYearMonth | RES-XP3-1 |
| `cbcl-hexBinary-equal-001` | test equality of xs:hexBinary | RES-XP3-1 |
| `cbcl-hexBinary-equal-002` | test equality of xs:hexBinary | RES-XP3-1 |
| `cbcl-hexBinary-equal-003` | test equality of xs:hexBinary | RES-XP3-1 |
| `hexBinary-gt-15` | Compare hexBinary values as part of sort operation | RES-XP3-1 |
| `hexBinary-gt-30` | test equality of xs:hexBinary | RES-XP3-1 |
| `hexBinary-gt-31` | test equality of xs:hexBinary | RES-XP3-1 |
| `hexBinary-gt-32` | test equality of xs:hexBinary | RES-XP3-1 |
| `hexBinary-lt-15` | Compare hexBinary values as part of sort operation | RES-XP3-1 |
| `hexBinary-lt-30` | test equality of xs:hexBinary | RES-XP3-1 |
| `hexBinary-lt-31` | test equality of xs:hexBinary | RES-XP3-1 |
| `hexBinary-lt-32` | test equality of xs:hexBinary | RES-XP3-1 |
| `fn-intersect-node-args-015` | arg: node and node | SHE-XSD |
| `fn-intersect-node-args-016` | arg: node & node | SHE-XSD |
| `fn-intersect-node-args-017` | arg: node & node | SHE-XSD |
| `fn-intersect-node-args-018` | arg: text node & text node | SHE-XSD |
| `fn-intersect-node-args-019` | arg: text node & text node | SHE-XSD |
| `fn-intersect-node-args-020` | arg: text node & text node | SHE-XSD |
| `fn-intersect-node-args-021` | arg: text node & text node | SHE-XSD |
| `fn-intersect-node-args-022` | arg: text node & text node | SHE-XSD |
| `fn-intersect-node-args-023` | arg: node & node | RES-XP3-1 |
| `K2-SeqIntersect-2` | Use a node kind keyword, text, to test query parsing. | RES-XP3-1 |
| `K2-SeqIntersect-3` | Use a node kind keyword, node, to test query parsing. | RES-XP3-1 |
| `K2-SeqIntersect-4` | Use a node kind keyword, element, to test query parsing. | RES-XP3-1 |
| `K2-SeqIntersect-5` | Use a node kind keyword, attribute, to test query parsing. | RES-XP3-1 |
| `K2-SeqIntersect-6` | Use a node kind keyword, document-node, to test query parsing. | RES-XP3-1 |
| `K2-SeqIntersect-7` | Use a node kind keyword, comment, to test query parsing. | RES-XP3-1 |
| `K2-SeqIntersect-8` | Use a node kind keyword, processing-instruction, to test query parsing. | RES-XP3-1 |
| `K2-SeqIntersect-9` | Use a node kind keyword, item, to test query parsing. | RES-XP3-1 |
| `K2-SeqIntersect-10` | Use a node kind keyword, document, to test query parsing. | RES-XP3-1 |
| `K2-SeqIntersect-11` | Use a node kind keyword, if, to test query parsing. | RES-XP3-1 |
| `K2-SeqIntersect-12` | Use a node kind keyword, then, to test query parsing. | RES-XP3-1 |
| `K2-SeqIntersect-13` | Use a node kind keyword, mod, to test query parsing. | RES-XP3-1 |
| `K2-SeqIntersect-14` | Use a node kind keyword, div, to test query parsing. | RES-XP3-1 |
| `K2-SeqIntersect-15` | Use a node kind keyword, empty-sequence, to test query parsing. | RES-XP3-1 |
| `K2-SeqIntersect-16` | Use a node kind keyword, schema-attribute, to test query parsing. | RES-XP3-1 |
| `K2-SeqIntersect-17` | Use a node kind keyword, schema-element, to test query parsing. | RES-XP3-1 |
| `K2-SeqIntersect-18` | Use a computed attribute constructor as right operand. | RES-XP3-1 |
| `K2-SeqIntersect-19` | Use a computed attribute constructor as right operand(#2). | RES-XP3-1 |
| `K2-SeqIntersect-20` | Use a computed attribute constructor as right operand. | RES-XP3-1 |
| `K2-SeqIntersect-21` | Use a computed attribute constructor as right operand(#2). | RES-XP3-1 |
| `K2-SeqIntersect-22` | Use a computed attribute constructor as right operand. | RES-XP3-1 |
| `K2-SeqIntersect-23` | Use a computed attribute constructor as right operand. | RES-XP3-1 |
| `K2-SeqIntersect-24` | Use a computed attribute constructor as right operand. | RES-XP3-1 |
| `K2-SeqIntersect-25` | Use a computed attribute constructor as right operand. | RES-XP3-1 |
| `K2-SeqIntersect-26` | Use a name test that is the descendant axis as right operand. | RES-XP3-1 |
| `K2-SeqIntersect-27` | Use a name test that is the attribute axis as right operand. | RES-XP3-1 |
| `K2-SeqIntersect-28` | Use a name test that is the self axis as right operand. | RES-XP3-1 |
| `K2-SeqIntersect-29` | Use a name test that is the descendant-or-self axis as right operand. | RES-XP3-1 |
| `K2-SeqIntersect-30` | Use a name test that is the following-sibling axis as right operand. | RES-XP3-1 |
| `K2-SeqIntersect-31` | Use a name test that is the following axis as right operand. | RES-XP3-1 |
| `K2-SeqIntersect-32` | Use a name test that is the preceding-sibling axis as right operand. | RES-XP3-1 |
| `K2-SeqIntersect-33` | Use a name test that is the preceding axis as right operand. | RES-XP3-1 |
| `K2-SeqIntersect-34` | Use a name test that is the parent axis as right operand. | RES-XP3-1 |
| `K2-SeqIntersect-35` | Use a name test that is the ancestor axis as right operand. | RES-XP3-1 |
| `K2-SeqIntersect-36` | Use a name test that is the ancestor axis as right operand. | RES-XP3-1 |
| `K2-SeqIntersect-37` | Use a name test that is the ancestor-or-self axis as right operand. | RES-XP3-1 |
| `K2-SeqIntersect-38` | Use 'declare as right operand. | RES-XP3-1 |
| `K2-SeqIntersect-41` | Ensure node deduplication is done. | RES-XP3-1 |
| `K2-SeqIntersect-42` | Perform intersection between two singleton document nodes. | RES-XP3-1 |
| `combiningnodeseqintersecthc1` | Simple combination of node sequences involving different node sequences that results in empty sequence . Use "intersect" operator. Uses the count function to avoid the empty file for results. | RES-XP3-1 |
| `combiningnodeseqintersecthc3` | Simple combination of sequences, where the two sequences are the same. Use "intersect" operator. | RES-XP3-1 |
| `combiningnodeseqintersecthc4` | Simple combination of sequences, where second sequence intersect first sequence (multiple data sources). Use "intersect" operator. | RES-XP3-1 |
| `nodeexpression2` | Test of a ComparisonExpression with the operands set as follows operand1 = empty Sequence operator = is operand2 = Single Element Constructor | RES-XP3-1 |
| `nodeexpression5` | Test of a ComparisonExpression with the operands set as follows operand1 = Single Element Constructor operator = is operand2 = empty Sequence | RES-XP3-1 |
| `nodeexpression6` | Test of a ComparisonExpression with the operands set as follows operand1 = Single Element Constructor operator = is operand2 = Single Element Constructor | RES-XP3-1 |
| `nodeexpression7` | Test of a ComparisonExpression with the operands set as follows operand1 = Single Element Constructor operator = is operand2 = Single Node Element | RES-XP3-1 |
| `nodeexpression8` | Test of a ComparisonExpression with the operands set as follows operand1 = Single Element Constructor operator = is operand2 = Sequence of single Element Node | RES-XP3-1 |
| `nodeexpression10` | Test of a ComparisonExpression with the operands set as follows operand1 = Single Node Element operator = is operand2 = Single Element Constructor | RES-XP3-1 |
| `nodeexpression14` | Test of a ComparisonExpression with the operands set as follows operand1 = Sequence of single Element Node operator = is operand2 = Single Element Constructor | RES-XP3-1 |
| `K2-NodeSame-1` | Ensure node identity is is correct for variables and element constructors. | RES-XP3-1 |
| `K2-NodeSame-2` | Ensure node identity is is correct between variable references. | RES-XP3-1 |
| `K2-NodeSame-3` | Ensure node identity is is correct for variables and element constructors(#2). | RES-XP3-1 |
| `K2-NodeSame-4` | Ensure node identity of nodes used with node constructors. | RES-XP3-1 |
| `K2-NodeSame-5` | exactly-one() to is, that fails. Inferrence may conclude that it will always evaluate to false, so that is valid as well. | RES-XP3-1 |
| `K2-NodeSame-6` | Compare two empty sequences, that are tricky to infer at compile time. | RES-XP3-1 |
| `cbcl-node-same-001` | test is same node operator | RES-XP3-1 |
| `cbcl-node-same-002` | test is same node operator | RES-XP3-1 |
| `cbcl-is-same-node-001` | Check node identity for return values of creative user defined functions. | RES-XP3-1 |
| `cbcl-multiply-dayTimeDuration-001` | test multiplication of xs:dayTimeDuration by 0 | RES-XP3-1 |
| `cbcl-multiply-dayTimeDuration-002` | test multiplication of xs:dayTimeDuration by 1 | RES-XP3-1 |
| `cbcl-multiply-dayTimeDuration-003` | test multiplication of xs:dayTimeDuration by NaN | RES-XP3-1 |
| `cbcl-multiply-dayTimeDuration-004` | test multiplication of xs:dayTimeDuration by 0 | RES-XP3-1 |
| `cbcl-multiply-dayTimeDuration-005` | test multiplication of xs:dayTimeDuration by 1 | RES-XP3-1 |
| `cbcl-multiply-dayTimeDuration-006` | test multiplication of xs:dayTimeDuration by NaN | RES-XP3-1 |
| `cbcl-times-001` | Test behaviour of times operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-times-002` | Test behaviour of times operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-times-003` | Test behaviour of times operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-times-004` | Test behaviour of times operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-times-005` | Test behaviour of times operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-times-006` | Test behaviour of times operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-times-007` | Test behaviour of times operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-times-008` | Test behaviour of times operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-multiply-yearMonthDuration-001` | test multiplication of xs:yearMonthDuration by 0 | RES-XP3-1 |
| `cbcl-multiply-yearMonthDuration-002` | test multiplication of xs:yearMonthDuration by 1 | RES-XP3-1 |
| `cbcl-multiply-yearMonthDuration-004` | test multiplication of xs:yearMonthDuration by 0 | RES-XP3-1 |
| `cbcl-multiply-yearMonthDuration-005` | test multiplication of xs:yearMonthDuration by 1 | RES-XP3-1 |
| `nodeexpression34` | Test of a ComparisonExpression with the operands set as follows operand1 = empty Sequence operator = >> operand2 = Single Element Constructor | RES-XP3-1 |
| `nodeexpression37` | Test of a ComparisonExpression with the operands set as follows operand1 = Single Element Constructor operator = >> operand2 = empty Sequence | RES-XP3-1 |
| `nodeexpression38` | Test of a ComparisonExpression with the operands set as follows operand1 = Single Element Constructor operator = >> operand2 = Single Element Constructor | RES-XP3-1 |
| `nodeexpression39` | Test of a ComparisonExpression with the operands set as follows operand1 = Single Element Constructor operator = >> operand2 = Single Node Element | RES-XP3-1 |
| `nodeexpression40` | Test of a ComparisonExpression with the operands set as follows operand1 = Single Element Constructor operator = >> operand2 = Sequence of single Element Node | RES-XP3-1 |
| `nodeexpression42` | Test of a ComparisonExpression with the operands set as follows operand1 = Single Node Element operator = >> operand2 = Single Element Constructor | RES-XP3-1 |
| `cbcl-numeric-less-than-016` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-less-than-017` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-less-than-018` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-less-than-019` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-less-than-020` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-less-than-021` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-less-than-022` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-less-than-023` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-less-than-024` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-less-than-025` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-less-than-026` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-less-than-027` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-less-than-028` | test comparison of integers | RES-XP3-1 |
| `cbcl-numeric-less-than-029` | test comparison of integers | RES-XP3-1 |
| `op-numeric-modmix2args-4` | Simple mod test, second operator is a node, atomization applied | RES-XP3-1 |
| `op-numeric-modmix2args-5` | Simple mod test, second operator is a node, atomization applied | RES-XP3-1 |
| `op-numeric-modmix2args-6` | Simple mod test, second operator node which is not atomizable | RES-XP3-1 |
| `op-numeric-modmix2args-7` | Simple mod test, two operands are nodes | RES-XP3-1 |
| `op-numeric-modmix2args-8` | Simple mod test, second operator is a node, atomizable but not castable to integer | RES-XP3-1 |
| `op-numeric-modmix2args-9` | Simple mod test pass an empty node for second operator | RES-XP3-1 |
| `K2-NumericMod-62` | Ensure the 'div' keyword is parsed correctly. | RES-XP3-1 |
| `op-numeric-mod-1` | Check dynamic type of numeric mod on arguments of union of numeric types and untypedAtomic. | RES-XP3-1 |
| `cbcl-numeric-mod-001` | ensure that taking the modulo xs:integers returns an xs:integer | RES-XP3-1 |
| `cbcl-numeric-mod-002` | ensure that taking the modulo xs:integers returns an xs:integer | RES-XP3-1 |
| `cbcl-numeric-mod-003` | Test numeric mod with a potential type check error | RES-XP3-1 |
| `op-numeric-multiplymix2args-4` | Simple multiplication test, second operator is a node, atomization applied | RES-XP3-1 |
| `op-numeric-multiplymix2args-5` | Simple multiplication test, second operator is a node, atomization applied | RES-XP3-1 |
| `op-numeric-multiplymix2args-6` | Simple multiplication test, second operator node which is not atomizable | RES-XP3-1 |
| `op-numeric-multiplymix2args-7` | Simple multiplication test, two operands are nodes | RES-XP3-1 |
| `op-numeric-multiplymix2args-8` | Simple multiplication test, second operator is a node, atomizable but not castable to integer | RES-XP3-1 |
| `op-numeric-multiplymix2args-9` | Simple multiplication test, pass an empty node for second operator | RES-XP3-1 |
| `op-numeric-multiplymix2args-10` | Simple multiplication test on xml document, with zero as second operand | RES-XP3-1 |
| `op-numeric-multiplymix2args-11` | Simple multiplication test on xml document, with negative number as second operand | RES-XP3-1 |
| `op-numeric-multiply-1` | Check dynamic type of numeric multiply on arguments of union of numeric types and untypedAtomic. | RES-XP3-1 |
| `cbcl-numeric-multiply-001` | test multiplication by xs:double NaN | RES-XP3-1 |
| `cbcl-numeric-multiply-002` | test multiplication by xs:double NaN | RES-XP3-1 |
| `cbcl-numeric-multiply-003` | test multiplication by xs:double 1 | RES-XP3-1 |
| `cbcl-numeric-multiply-004` | test multiplication by xs:double 1 | RES-XP3-1 |
| `cbcl-numeric-multiply-005` | test multiplication by xs:double -1 | RES-XP3-1 |
| `cbcl-numeric-multiply-006` | test multiplication by xs:double -1 | RES-XP3-1 |
| `cbcl-numeric-multiply-007` | test multiplication by xs:float NaN | RES-XP3-1 |
| `cbcl-numeric-multiply-008` | test multiplication by xs:float NaN | RES-XP3-1 |
| `cbcl-numeric-multiply-009` | test multiplication by xs:float 1 | RES-XP3-1 |
| `cbcl-numeric-multiply-010` | test multiplication by xs:float 1 | RES-XP3-1 |
| `cbcl-numeric-multiply-011` | test multiplication by xs:float -1 | RES-XP3-1 |
| `cbcl-numeric-multiply-012` | test multiplication by xs:float -1 | RES-XP3-1 |
| `cbcl-numeric-multiply-013` | test multiplication by xs:decimal 0 | RES-XP3-1 |
| `cbcl-numeric-multiply-014` | test multiplication by xs:decimal 0 | RES-XP3-1 |
| `cbcl-numeric-multiply-015` | test multiplication by xs:decimal 1 | RES-XP3-1 |
| `cbcl-numeric-multiply-016` | test multiplication by xs:decimal 1 | RES-XP3-1 |
| `cbcl-numeric-multiply-017` | test multiplication by xs:decimal -1 | RES-XP3-1 |
| `cbcl-numeric-multiply-018` | test multiplication by xs:decimal -1 | RES-XP3-1 |
| `cbcl-numeric-multiply-019` | test multiplication by xs:integer 0 | RES-XP3-1 |
| `cbcl-numeric-multiply-020` | test multiplication by xs:integer 0 | RES-XP3-1 |
| `cbcl-numeric-multiply-021` | test multiplication by xs:integer 1 | RES-XP3-1 |
| `cbcl-numeric-multiply-022` | test multiplication by xs:integer 1 | RES-XP3-1 |
| `cbcl-numeric-multiply-023` | test multiplication by xs:integer -1 | RES-XP3-1 |
| `cbcl-numeric-multiply-024` | test multiplication by xs:integer -1 | RES-XP3-1 |
| `cbcl-numeric-multiply-025` | test multiplication of large xs:decimal | RES-XP3-1 |
| `cbcl-numeric-multiply-026` | test multiplication of large xs:integer | RES-XP3-1 |
| `cbcl-numeric-multiply-027` | ensure that multiplying xs:integers returns an xs:integer | RES-XP3-1 |
| `op-numeric-subtractmix2args-4` | Simple subtraction test, second operator is a node, atomization applied | RES-XP3-1 |
| `op-numeric-subtractmix2args-5` | Simple subtraction test, second operator is a node, atomization applied | RES-XP3-1 |
| `op-numeric-subtractmix2args-6` | Simple subtraction test, second operator node which is not atomizable | RES-XP3-1 |
| `op-numeric-subtractmix2args-7` | Simple subtraction test, two operands are nodes | RES-XP3-1 |
| `op-numeric-subtractmix2args-8` | Simple subtraction test, second operator is a node, atomizable but not castable to integer | RES-XP3-1 |
| `op-numeric-subtractmix2args-9` | Simple subtraction test pass an empty node for second operator | RES-XP3-1 |
| `op-numeric-subtract-1` | Check dynamic type of numeric subtract on arguments of union of numeric types and untypedAtomic. | RES-XP3-1 |
| `cbcl-numeric-subtract-003` | test subtraction of xs:decimal 0 | RES-XP3-1 |
| `cbcl-numeric-subtract-004` | test subtraction of xs:integer 0 | RES-XP3-1 |
| `cbcl-numeric-subtract-005` | ensure that subtracting xs:integers returns an xs:integer | RES-XP3-1 |
| `cbcl-numeric-subtract-006` | test subtraction of negated integers | RES-XP3-1 |
| `cbcl-numeric-subtract-007` | test subtraction of negated integers | RES-XP3-1 |
| `cbcl-numeric-subtract-008` | test subtraction of negated integers | RES-XP3-1 |
| `K2-NumericUnaryMinus-8` | Unary combined with path expressions. | RES-XP3-1 |
| `K2-NumericUnaryMinus-10` | A tricky operand, which requires various forms of argument conversion. | RES-XP3-1 |
| `op-numeric-unary-minus-1` | Check dynamic type of unary plus on argument of union of numeric types and untypedAtomic. | RES-XP3-1 |
| `cbcl-numeric-unary-minus-001` | Test unary minus with a potential type check error | RES-XP3-1 |
| `K2-NumericUnaryPlus-1` | Unary combined with path expressions. | RES-XP3-1 |
| `op-numeric-unary-plus-1` | Check dynamic type of unary plus on argument of union of numeric types and untypedAtomic. | RES-XP3-1 |
| `cbcl-numeric-unary-plus-001` | Test unary plus with a potential type check error | RES-XP3-1 |
| `cbcl-QName-equal-001` | test equality of xs:QName | RES-XP3-1 |
| `cbcl-QName-equal-002` | test equality of xs:QName | RES-XP3-1 |
| `K2-StringEqual-1` | Compare two values returned from fn:lower-case(). | RES-XP3-1 |
| `K2-StringEqual-2` | Compare two values returned from fn:upper-case(). | RES-XP3-1 |
| `K2-StringEqual-3` | Compare two non-matching values returned from fn:lower-case(). | RES-XP3-1 |
| `K2-StringEqual-4` | Compare two non-matching values returned from fn:upper-case(). | RES-XP3-1 |
| `K2-StringEqual-5` | Compare two non-matching values returned from fn:lower-case() and fn:upper-case(). | RES-XP3-1 |
| `K2-StringEqual-6` | Compare two non-matching values returned from fn:lower-case() and fn:upper-case(). | RES-XP3-1 |
| `cbcl-subtract-dayTimeDuration-from-date-001` | test subtraction of zero duration from date | RES-XP3-1 |
| `cbcl-subtract-dayTimeDuration-from-date-002` | test subtraction of large duration from date | RES-XP3-1 |
| `cbcl-subtract-dayTimeDuration-from-dateTime-001` | test subtraction of zero duration from dateTime | RES-XP3-1 |
| `cbcl-subtract-dayTimeDuration-from-dateTime-002` | test subtraction of large duration from date | RES-XP3-1 |
| `cbcl-subtract-dayTimeDuration-from-time-001` | test subtraction of zero duration from time | RES-XP3-1 |
| `cbcl-subtract-dayTimeDurations-001` | test subtraction of zero duration from dayTimeDuration | RES-XP3-1 |
| `cbcl-subtract-dayTimeDurations-002` | test subtraction of dayTimeDurations | RES-XP3-1 |
| `cbcl-subtract-dayTimeDurations-003` | test subtraction of large dayTimeDuration | RES-XP3-1 |
| `cbcl-minus-001` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-002` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-003` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-004` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-005` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-006` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-007` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-008` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-009` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-010` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-011` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-012` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-013` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-014` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-015` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-016` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-017` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-018` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-019` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-020` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-021` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-022` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-023` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-024` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-025` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-026` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-027` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-028` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-029` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-030` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-031` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-032` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-033` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-minus-034` | Test behaviour of minus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-subtract-yearMonthDuration-from-date-001` | test subtraction of zero duration to date | RES-XP3-1 |
| `cbcl-subtract-yearMonthDuration-from-date-002` | test subtraction of large duration from date | RES-XP3-1 |
| `cbcl-subtract-yearMonthDuration-from-dateTime-001` | test subtraction of zero duration to dateTime | RES-XP3-1 |
| `cbcl-subtract-yearMonthDuration-from-dateTime-002` | test subtraction of large duration from dateTime | RES-XP3-1 |
| `cbcl-subtract-yearMonthDurations-001` | test subtraction of zero duration from yearMonthDurations | RES-XP3-1 |
| `cbcl-subtract-yearMonthDurations-002` | test subtraction of yearMonthDurations | RES-XP3-1 |
| `cbcl-subtract-yearMonthDurations-003` | test subtraction of large yearMonthDuration | RES-XP3-1 |
| `cbcl-time-equal-001` | test comparison of time | RES-XP3-1 |
| `cbcl-time-equal-006` | test comparison of time | RES-XP3-1 |
| `cbcl-time-equal-011` | test comparison of time | RES-XP3-1 |
| `cbcl-time-equal-012` | test comparison of time | RES-XP3-1 |
| `cbcl-time-equal-013` | test comparison of time | RES-XP3-1 |
| `cbcl-time-equal-014` | test comparison of time | RES-XP3-1 |
| `cbcl-time-greater-than-001` | test comparison of time | RES-XP3-1 |
| `cbcl-time-greater-than-006` | test comparison of time | RES-XP3-1 |
| `cbcl-time-greater-than-011` | test comparison of time | RES-XP3-1 |
| `cbcl-time-greater-than-012` | test comparison of time | RES-XP3-1 |
| `cbcl-time-greater-than-013` | test comparison of time | RES-XP3-1 |
| `cbcl-time-greater-than-014` | test comparison of time | RES-XP3-1 |
| `cbcl-add-dayTimeDurations-001` | test addition of zero duration to dayTimeDuration | RES-XP3-1 |
| `cbcl-add-dayTimeDurations-002` | test addition of zero duration to dayTimeDuration | RES-XP3-1 |
| `cbcl-add-dayTimeDurations-003` | test addition of dayTimeDurations | RES-XP3-1 |
| `cbcl-plus-001` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-002` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-003` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-004` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-005` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-006` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-007` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-008` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-009` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-010` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-011` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-012` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-013` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-014` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-015` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-016` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-017` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-018` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-019` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-020` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-021` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-022` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-023` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-024` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-025` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-026` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-027` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-028` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-029` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-030` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-031` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-032` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-033` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-plus-034` | Test behaviour of plus operator when presented with an expression with static type duration | RES-XP3-1 |
| `cbcl-add-dayTimeDuration-to-date-001` | test addition of zero duration to date | RES-XP3-1 |
| `cbcl-add-dayTimeDuration-to-date-002` | test addition of zero duration to date | RES-XP3-1 |
| `cbcl-add-dayTimeDuration-to-date-003` | test addition of large duration to date | RES-XP3-1 |
| `Add-UnionType-36` | Add a union type to a duration | RES-XP3-1, SHE-XSD |
| `Add-UnionType-37` | Add a union type to a duration | RES-XP3-1, SHE-XSD |
| `cbcl-add-dayTimeDuration-to-dateTime-001` | test addition of zero duration to dateTime | RES-XP3-1 |
| `cbcl-add-dayTimeDuration-to-dateTime-002` | test addition of zero duration to dateTime | RES-XP3-1 |
| `cbcl-add-dayTimeDuration-to-dateTime-003` | test addition of large duration to date | RES-XP3-1 |
| `cbcl-add-dayTimeDuration-to-time-001` | test addition of zero duration to time | RES-XP3-1 |
| `cbcl-add-dayTimeDuration-to-time-002` | test addition of zero duration to time | RES-XP3-1 |
| `cbcl-add-yearMonthDurations-001` | test addition of zero duration to yearMonthDuration | RES-XP3-1 |
| `cbcl-add-yearMonthDurations-002` | test addition of zero duration to yearMonthDuration | RES-XP3-1 |
| `cbcl-add-yearMonthDurations-003` | test addition of zero duration to yearMonthDuration | RES-XP3-1 |
| `cbcl-add-yearMonthDuration-to-date-001` | test addition of zero duration to date | RES-XP3-1 |
| `cbcl-add-yearMonthDuration-to-date-002` | test addition of zero duration to date | RES-XP3-1 |
| `cbcl-add-yearMonthDuration-to-date-003` | test addition of large duration to date | RES-XP3-1 |
| `cbcl-add-yearMonthDuration-to-dateTime-001` | test addition of zero duration to dateTime | RES-XP3-1 |
| `cbcl-add-yearMonthDuration-to-dateTime-002` | test addition of zero duration to dateTime | RES-XP3-1 |
| `cbcl-add-yearMonthDuration-to-dateTime-003` | test addition of large duration to dateTime | RES-XP3-1 |
| `cbcl-base64Binary-equal-001` | Name: cbcl-base64Binary-equal-001 Description: test equality of xs:base64Binary Author: Tim Mills Date: 2008-05-14 | RES-XP3-1 |
| `cbcl-base64Binary-equal-002` | Name: cbcl-base64Binary-equal-002 Description: test equality of xs:base64Binary Author: Tim Mills Date: 2008-05-14 | RES-XP3-1 |
| `cbcl-base64Binary-equal-003` | Name: cbcl-base64Binary-equal-003 Description: test equality of xs:base64Binary Author: Tim Mills Date: 2008-05-14 | RES-XP3-1 |
| `base64Binary-lt-15` | Compare base64Binary values as part of sort operation | RES-XP3-1 |
| `base64Binary-lt-30` | test equality of xs:base64Binary | RES-XP3-1 |
| `base64Binary-lt-31` | test equality of xs:base64Binary | RES-XP3-1 |
| `base64Binary-lt-32` | test equality of xs:base64Binary | RES-XP3-1 |
| `base64Binary-gt-15` | Compare base64Binary values as part of sort operation | RES-XP3-1 |
| `base64Binary-gt-30` | test equality of xs:base64Binary | RES-XP3-1 |
| `base64Binary-gt-31` | test equality of xs:base64Binary | RES-XP3-1 |
| `base64Binary-gt-32` | test equality of xs:base64Binary | RES-XP3-1 |
| `K2-BooleanEqual-2` | ******************************************************* Test: K2-BooleanEqual-2 Written by: Frans Englich Date: 2007-11-22T11:31:21+01:00 Purpose: Cannot compare xs:boolean and xs:untypedAtomic. ******************************************************* | RES-XP3-1 |
| `K2-BooleanEqual-3` | ******************************************************* Test: K2-BooleanEqual-3 Written by: Frans Englich Date: 2007-11-22T11:31:21+01:00 Purpose: Cannot compare xs:boolean and xs:untypedAtomic(#2). ******************************************************* | RES-XP3-1 |
| `cbcl-boolean-equal-001` | Name: cbcl-boolean-equal-001 Description: test equality of xs:boolean Author: Tim Mills Date: 2008-05-14 | RES-XP3-1 |
| `cbcl-boolean-equal-002` | Name: cbcl-boolean-equal-002 Description: test equality of xs:boolean Author: Tim Mills Date: 2008-05-14 | RES-XP3-1 |
| `cbcl-boolean-equal-003` | Name: cbcl-boolean-equal-003 Description: test equality of xs:boolean Author: Tim Mills Date: 2008-05-14 | RES-XP3-1 |
| `cbcl-boolean-equal-004` | Name: cbcl-boolean-equal-004 Description: test equality of xs:boolean Author: Tim Mills Date: 2008-05-14 | RES-XP3-1 |
| `cbcl-boolean-equal-005` | test equality of xs:boolean | RES-XP3-1 |
| `cbcl-boolean-equal-006` | test equal to of xs:boolean | RES-XP3-1 |
| `cbcl-boolean-greater-than-001` |  | RES-XP3-1 |
| `cbcl-boolean-greater-than-002` |  | RES-XP3-1 |
| `cbcl-boolean-greater-than-003` |  | RES-XP3-1 |
| `cbcl-boolean-greater-than-004` |  | RES-XP3-1 |
| `cbcl-boolean-greater-than-005` |  | RES-XP3-1 |
| `cbcl-boolean-greater-than-006` |  | RES-XP3-1 |
| `cbcl-boolean-greater-than-007` |  | RES-XP3-1 |
| `cbcl-boolean-greater-than-008` |  | RES-XP3-1 |
| `cbcl-boolean-greater-than-009` |  | RES-XP3-1 |
| `cbcl-boolean-greater-than-010` |  | RES-XP3-1 |
| `cbcl-boolean-less-than-001` |  | RES-XP3-1 |
| `cbcl-boolean-less-than-002` |  | RES-XP3-1 |
| `cbcl-boolean-less-than-003` |  | RES-XP3-1 |
| `cbcl-boolean-less-than-004` |  | RES-XP3-1 |
| `cbcl-boolean-less-than-005` |  | RES-XP3-1 |
| `cbcl-boolean-less-than-006` |  | RES-XP3-1 |
| `cbcl-boolean-less-than-007` |  | RES-XP3-1 |
| `cbcl-boolean-less-than-008` |  | RES-XP3-1 |
| `cbcl-boolean-less-than-009` |  | RES-XP3-1 |
| `cbcl-boolean-less-than-010` |  | RES-XP3-1 |
| `cbcl-date-equal-001` | test comparison of date | RES-XP3-1 |
| `cbcl-date-equal-006` | test comparison of date | RES-XP3-1 |
| `cbcl-date-equal-011` | test comparison of date | RES-XP3-1 |
| `cbcl-date-equal-012` | test comparison of date | RES-XP3-1 |
| `cbcl-date-equal-013` | test comparison of date | RES-XP3-1 |
| `cbcl-date-equal-014` | test comparison of date | RES-XP3-1 |
| `cbcl-date-equal-015` | test comparison of date | RES-XP3-1 |
| `cbcl-date-equal-016` | test comparison of date | RES-XP3-1 |
| `cbcl-date-le-001` | Test that comparing large dates does not overflow. | RES-XP3-1 |
| `cbcl-date-greater-equal-001` | test comparison of date | RES-XP3-1 |
| `cbcl-date-greater-equal-006` | test comparison of date | RES-XP3-1 |
| `cbcl-date-greater-than-011` | test comparison of date | RES-XP3-1 |
| `cbcl-date-greater-than-012` | test comparison of date | RES-XP3-1 |
| `cbcl-date-greater-than-013` | test comparison of date | RES-XP3-1 |
| `cbcl-date-greater-than-014` | test comparison of date | RES-XP3-1 |
| `cbcl-date-greater-than-015` | test comparison of date | RES-XP3-1 |
| `cbcl-date-greater-than-016` | test comparison of date | RES-XP3-1 |
| `cbcl-date-lt-001` | Test that comparing large dates does not overflow. | RES-XP3-1 |
| `cbcl-date-less-than-001` | test comparison of date | RES-XP3-1 |
| `cbcl-date-less-than-006` | test comparison of date | RES-XP3-1 |
| `cbcl-date-less-than-011` | test comparison of date | RES-XP3-1 |
| `cbcl-date-less-than-012` | test comparison of date | RES-XP3-1 |
| `cbcl-date-less-than-013` | test comparison of date | RES-XP3-1 |
| `cbcl-date-less-than-014` | test comparison of date | RES-XP3-1 |
| `cbcl-date-less-than-015` | test comparison of date | RES-XP3-1 |
| `cbcl-date-less-than-016` | test comparison of date | RES-XP3-1 |
| `cbcl-dateTime-equal-001` | test comparison of dateTime | RES-XP3-1 |
| `cbcl-dateTime-equal-006` | test comparison of dateTime | RES-XP3-1 |
| `cbcl-dateTime-equal-011` | test comparison of dateTime | RES-XP3-1 |
| `cbcl-dateTime-equal-012` | test comparison of dateTime | RES-XP3-1 |
| `cbcl-dateTime-equal-013` | test comparison of dateTime | RES-XP3-1 |
| `cbcl-dateTime-equal-014` | test comparison of dateTime | RES-XP3-1 |
| `cbcl-dateTime-equal-015` | test comparison of dateTime | RES-XP3-1 |
| `cbcl-dateTime-equal-016` | test comparison of dateTime | RES-XP3-1 |
| `UnionType-equal-01` | Compare a union type to a dateTime | RES-XP3-1, SHE-XSD |
| `UnionType-equal-02` | Compare a union type to a dateTime | RES-XP3-1, SHE-XSD |
| `cbcl-dateTime-greater-than-001` | test comparison of dateTime | RES-XP3-1 |
| `cbcl-dateTime-greater-than-006` | test comparison of dateTime | RES-XP3-1 |
| `cbcl-dateTime-greater-than-011` | test comparison of dateTime | RES-XP3-1 |
| `cbcl-dateTime-greater-than-012` | test comparison of dateTime | RES-XP3-1 |
| `cbcl-dateTime-greater-than-013` | test comparison of dateTime | RES-XP3-1 |
| `cbcl-dateTime-greater-than-014` | test comparison of dateTime | RES-XP3-1 |
| `cbcl-dateTime-greater-than-015` | test comparison of dateTime | RES-XP3-1 |
| `cbcl-dateTime-greater-than-016` | test comparison of dateTime | RES-XP3-1 |
| `cbcl-dateTime-less-than-001` | test comparison of dateTime | RES-XP3-1 |
| `cbcl-dateTime-less-than-006` | test comparison of dateTime | RES-XP3-1 |
| `cbcl-dateTime-less-than-011` | test comparison of dateTime | RES-XP3-1 |
| `cbcl-dateTime-less-than-012` | test comparison of dateTime | RES-XP3-1 |
| `cbcl-dateTime-less-than-013` | test comparison of dateTime | RES-XP3-1 |
| `cbcl-dateTime-less-than-014` | test comparison of dateTime | RES-XP3-1 |
| `cbcl-dateTime-less-than-015` | test comparison of dateTime | RES-XP3-1 |
| `cbcl-dateTime-less-than-016` | test comparison of dateTime | RES-XP3-1 |