Package ee.jakarta.tck.el.spec.relationaloperator

Class ELClientIT

java.lang.Object
ee.jakarta.tck.el.spec.relationaloperator.ELClientIT
public class ELClientIT extends Object

  • Constructor Details

    • ELClientIT

      public ELClientIT()

  • Method Details

    • cleanup

      @AfterEach public void cleanup() throws Exception
      Throws:
      Exception

    • elEqualOperandLessThanOrEqualTest

      @Test public void elEqualOperandLessThanOrEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elEqualOperandLessThanOrEqualTest
      Assertion IDs:
      EL:SPEC:21.1
      Test Strategy:
      Validate that if the operands in an EL <= or le operation are equal, the result is true.

    • elEqualOperandGreaterThanOrEqualTest

      @Test public void elEqualOperandGreaterThanOrEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elEqualOperandGreaterThanOrEqualTest
      Assertion IDs:
      EL:SPEC:21.1
      Test Strategy:
      Validate that if the operands in an EL >= or ge operation are equal, the result is true.

    • elNullOperandLessThanOrEqualTest

      @Test public void elNullOperandLessThanOrEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elNullOperandLessThanOrEqualTest
      Assertion IDs:
      EL:SPEC:21.2
      Test Strategy:
      Validate that if one of the operands in an EL <= or le operation is null, the result is false.

    • elNullOperandGreaterThanOrEqualTest

      @Test public void elNullOperandGreaterThanOrEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elNullOperandGreaterThanOrEqualTest
      Assertion IDs:
      EL:SPEC:21.2
      Test Strategy:
      Validate that if one of the operands in an EL >= or ge operation is null, the result is false.

    • elNullOperandNotEqualTest

      @Test public void elNullOperandNotEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elNullOperandNotEqualTest
      Assertion IDs:
      EL:SPEC:22.2
      Test Strategy:
      Validate that if one of the operands is null in an EL !=, ne operation return true.

    • elNullOperandEqualTest

      @Test public void elNullOperandEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elNullOperandEqualTest
      Assertion IDs:
      EL:SPEC:22.2
      Test Strategy:
      Validate that if one of the operands is null in an EL =, eq operation return false.

    • elBigDecimalLessThanTest

      @Test public void elBigDecimalLessThanTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBigDecimalLessThanTest
      Assertion IDs:
      EL:SPEC:21.3
      Test Strategy:
      Validate that if one of the operands in an EL "<" or "lt" operation is a BigDecimal, the result is coerced to BigDecimal and the correct boolean value is returned. Equations tested: BigDecimal "<" & "lt" BigDecimal BigDecimal "<" & "lt" Double BigDecimal "<" & "lt" Float BigDecimal "<" & "lt" BigInteger BigDecimal "<" & "lt" Integer BigDecimal "<" & "lt" Long BigDecimal "<" & "lt" Short BigDecimal "<" & "lt" Byte

    • elBigDecimalLessThanEqualTest

      @Test public void elBigDecimalLessThanEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBigDecimalLessThanEqualTest
      Assertion IDs:
      EL:SPEC:21.1; EL:SPEC:21.3
      Test Strategy:
      Validate that if one of the operands in an EL "<=" or "le" operation is a BigDecimal, the result is coerced to BigDecimal and the correct boolean value is returned. Equations tested: BigDecimal "<=" & "le" BigDecimal BigDecimal "<=" & "le" Double BigDecimal "<=" & "le" Float BigDecimal "<=" & "le" BigInteger BigDecimal "<=" & "le" Integer BigDecimal "<=" & "le" Long BigDecimal "<=" & "le" Short BigDecimal "<=" & "le" Byte

    • elBigDecimalGreaterThanTest

      @Test public void elBigDecimalGreaterThanTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBigDecimalGreaterThanTest
      Assertion IDs:
      EL:SPEC:21.3
      Test Strategy:
      Validate that if one of the operands in an EL ">" or "gt" operation is a BigDecimal, the result is coerced to BigDecimal and the correct boolean value is returned. Equations tested: BigDecimal ">" & "gt" BigDecimal BigDecimal ">" & "gt" Double BigDecimal ">" & "gt" Float BigDecimal ">" & "gt" BigInteger BigDecimal ">" & "gt" Integer BigDecimal ">" & "gt" Long BigDecimal ">" & "gt" Short BigDecimal ">" & "gt" Byte

    • elBigDecimalGreaterThanEqualTest

      @Test public void elBigDecimalGreaterThanEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBigDecimalGreaterThanEqualTest
      Assertion IDs:
      EL:SPEC:21.1; EL:SPEC:21.3
      Test Strategy:
      Validate that if one of the operands in an EL ">=" or "ge" operation is a BigDecimal, the result is coerced to BigDecimal and the correct boolean value is returned. Equations tested: BigDecimal ">=" & "ge" BigDecimal BigDecimal ">=" & "ge" Double BigDecimal ">=" & "ge" Float BigDecimal ">=" & "ge" BigInteger BigDecimal ">=" & "ge" Integer BigDecimal ">=" & "ge" Long BigDecimal ">=" & "ge" Short BigDecimal ">=" & "ge" Byte

    • elBigDecimalEqualToTest

      @Test public void elBigDecimalEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBigDecimalEqualToTest
      Assertion IDs:
      EL:SPEC:22.1; EL:SPEC:22.3.1
      Test Strategy:
      Validate that if one of the operands in an EL "==" or "eq" operation is a BigDecimal, the result is coerced to BigDecimal and the correct boolean value is returned. Equations tested: BigDecimal "==" & "eq" BigDecimal BigDecimal "==" & "eq" Double BigDecimal "==" & "eq" Float BigDecimal "==" & "eq" BigInteger BigDecimal "==" & "eq" Integer BigDecimal "==" & "eq" Long BigDecimal "==" & "eq" Short BigDecimal "==" & "eq" Byte

    • elBigDecimalNotEqualToTest

      @Test public void elBigDecimalNotEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBigDecimalNotEqualToTest
      Assertion IDs:
      EL:SPEC:22.3.2
      Test Strategy:
      Validate that if one of the operands in an EL "!=" or "ne" operation is a BigDecimal, the result is coerced to BigDecimal and the correct boolean value is returned. Equations tested: BigDecimal "!=" & "ne" BigDecimal BigDecimal "!=" & "ne" Double BigDecimal "!=" & "ne" Float BigDecimal "!=" & "ne" BigInteger BigDecimal "!=" & "ne" Integer BigDecimal "!=" & "ne" Long BigDecimal "!=" & "ne" Short BigDecimal "!=" & "ne" Byte

    • elFloatLessThanTest

      @Test public void elFloatLessThanTest() throws Exception
      Throws:
      Exception
      Test Name:
      elFloatLessThanTest
      Assertion IDs:
      EL:SPEC:21.4
      Test Strategy:
      Validate that if one of the operands in an EL "<" or "lt" operation is a Float, the result is coerced to Double and the correct boolean value is returned. Equations tested: Float "<" & "lt" Double Float "<" & "lt" Float Float "<" & "lt" BigInteger Float "<" & "lt" Integer Float "<" & "lt" Long Float "<" & "lt" Short Float "<" & "lt" Byte

    • elFloatLessThanEqualTest

      @Test public void elFloatLessThanEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elFloatLessThanEqualTest
      Assertion IDs:
      EL:SPEC:21.1; EL:SPEC:21.4
      Test Strategy:
      Validate that if one of the operands in an EL "<=" or "le" operation is a Float, the result is coerced to Double and the correct boolean value is returned. Equations tested: Float "<=" & "le" Double Float "<=" & "le" Float Float "<=" & "le" BigInteger Float "<=" & "le" Integer Float "<=" & "le" Long Float "<=" & "le" Short Float "<=" & "le" Byte

    • elFloatGreaterThanTest

      @Test public void elFloatGreaterThanTest() throws Exception
      Throws:
      Exception
      Test Name:
      elFloatGreaterThanTest
      Assertion IDs:
      EL:SPEC:21.4
      Test Strategy:
      Validate that if one of the operands in an EL ">" or "gt" operation is a Float, the result is coerced to Double and the correct boolean value is returned. Equations tested: Float ">" & "gt" Double Float ">" & "gt" Float Float ">" & "gt" BigInteger Float ">" & "gt" Integer Float ">" & "gt" Long Float ">" & "gt" Short Float ">" & "gt" Byte

    • elFloatGreaterThanEqualTest

      @Test public void elFloatGreaterThanEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elFloatGreaterThanEqualTest
      Assertion IDs:
      EL:SPEC:21.1; EL:SPEC:21.4
      Test Strategy:
      Validate that if one of the operands in an EL ">=" or "ge" operation is a Float, the result is coerced to Double and the correct boolean value is returned. Equations tested: Float ">=" & "ge" Double Float ">=" & "ge" Float Float ">=" & "ge" BigInteger Float ">=" & "ge" Integer Float ">=" & "ge" Long Float ">=" & "ge" Short Float ">=" & "ge" Byte

    • elFloatEqualToTest

      @Test public void elFloatEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elFloatEqualToTest
      Assertion IDs:
      EL:SPEC:22.1; EL:SPEC:22.4
      Test Strategy:
      Validate that if one of the operands in an EL "==" or "eq" operation is a Float, the result is coerced to Double and the correct boolean value is returned. Equations tested: Float "==" & "eq" Double Float "==" & "eq" Float Float "==" & "eq" BigInteger Float "==" & "eq" Integer Float "==" & "eq" Long Float "==" & "eq" Short Float "==" & "eq" Byte

    • elFloatNotEqualToTest

      @Test public void elFloatNotEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elFloatNotEqualToTest
      Assertion IDs:
      EL:SPEC:22.4
      Test Strategy:
      Validate that if one of the operands in an EL "!=" or "ne" operation is a Float, the result is coerced to Double and the correct boolean value is returned. Equations tested: Float "!=" & "ne" Double Float "!=" & "ne" Float Float "!=" & "ne" BigInteger Float "!=" & "ne" Integer Float "!=" & "ne" Long Float "!=" & "ne" Short Float "!=" & "ne" Byte

    • elDoubleLessThanTest

      @Test public void elDoubleLessThanTest() throws Exception
      Throws:
      Exception
      Test Name:
      elDoubleLessThanTest
      Assertion IDs:
      EL:SPEC:21.4
      Test Strategy:
      Validate that if one of the operands in an EL "<" or "lt" operation is a Double, the result is coerced to Double and the correct boolean value is returned. Equations tested: Double "<" & "lt" Double Double "<" & "lt" BigInteger Double "<" & "lt" Integer Double "<" & "lt" Long Double "<" & "lt" Short Double "<" & "lt" Byte

    • elDoubleLessThanEqualTest

      @Test public void elDoubleLessThanEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elDoubleLessThanEqualTest
      Assertion IDs:
      EL:SPEC:21.1; EL:SPEC:21.4
      Test Strategy:
      Validate that if one of the operands in an EL "<=" or "le" operation is a Double, the result is coerced to Double and the correct boolean value is returned. Equations tested: Double "<=" & "le" Double Double "<=" & "le" BigInteger Double "<=" & "le" Integer Double "<=" & "le" Long Double "<=" & "le" Short Double "<=" & "le" Byte

    • elDoubleGreaterThanTest

      @Test public void elDoubleGreaterThanTest() throws Exception
      Throws:
      Exception
      Test Name:
      elDoubleGreaterThanTest
      Assertion IDs:
      EL:SPEC:21.4
      Test Strategy:
      Validate that if one of the operands in an EL ">" or "gt" operation is a Double, the result is coerced to Double and the correct boolean value is returned. Equations tested: Double ">" & "gt" Double Double ">" & "gt" BigInteger Double ">" & "gt" Integer Double ">" & "gt" Long Double ">" & "gt" Short Double ">" & "gt" Byte

    • elDoubleGreaterThanEqualTest

      @Test public void elDoubleGreaterThanEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elDoubleGreaterThanEqualTest
      Assertion IDs:
      EL:SPEC:21.1; EL:SPEC:21.4
      Test Strategy:
      Validate that if one of the operands in an EL ">=" or "ge" operation is a Double, the result is coerced to Double and the correct boolean value is returned. Equations tested: Double ">=" & "ge" Double Double ">=" & "ge" BigInteger Double ">=" & "ge" Integer Double ">=" & "ge" Long Double ">=" & "ge" Short Double ">=" & "ge" Byte

    • elDoubleEqualToTest

      @Test public void elDoubleEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elDoubleEqualToTest
      Assertion IDs:
      EL:SPEC:22.1; EL:SPEC:22.4
      Test Strategy:
      Validate that if one of the operands in an EL "==" or "eq" operation is a Double, the result is coerced to Double and the correct boolean value is returned. Equations tested: Double "==" & "eq" Double Double "==" & "eq" BigInteger Double "==" & "eq" Integer Double "==" & "eq" Long Double "==" & "eq" Short Double "==" & "eq" Byte

    • elDoubleNotEqualToTest

      @Test public void elDoubleNotEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elDoubleNotEqualToTest
      Assertion IDs:
      EL:SPEC:22.4
      Test Strategy:
      Validate that if one of the operands in an EL "!=" or "ne" operation is a Double, the result is coerced to Double and the correct boolean value is returned. Equations tested: Double "!=" & "ne" Double Double "!=" & "ne" BigInteger Double "!=" & "ne" Integer Double "!=" & "ne" Long Double "!=" & "ne" Short Double "!=" & "ne" Byte

    • elBigIntegerLessThanTest

      @Test public void elBigIntegerLessThanTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBigIntegerLessThanTest
      Assertion IDs:
      EL:SPEC:21.5
      Test Strategy:
      Validate that if one of the operands in an EL "<" or "lt" operation is a BigInteger, the result is coerced to BigInteger and the correct boolean value is returned. Equations tested: BigInteger "<" & "lt" BigInteger BigInteger "<" & "lt" Integer BigInteger "<" & "lt" Long BigInteger "<" & "lt" Short BigInteger "<" & "lt" Byte

    • elBigIntegerLessThanEqualTest

      @Test public void elBigIntegerLessThanEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBigIntegerLessThanEqualTest
      Assertion IDs:
      EL:SPEC:21.1; EL:SPEC:21.5
      Test Strategy:
      Validate that if one of the operands in an EL "<=" or "le" operation is a BigInteger, the result is coerced to BigInteger and the correct boolean value is returned. Equations tested: BigInteger "<=" & "le" BigInteger BigInteger "<=" & "le" Integer BigInteger "<=" & "le" Long BigInteger "<=" & "le" Short BigInteger "<=" & "le" Byte

    • elBigIntegerGreaterThanTest

      @Test public void elBigIntegerGreaterThanTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBigIntegerGreaterThanTest
      Assertion IDs:
      EL:SPEC:21.5
      Test Strategy:
      Validate that if one of the operands in an EL ">" or "gt" operation is a BigInteger, the result is coerced to BigInteger and the correct boolean value is returned. Equations tested: BigInteger ">" & "gt" BigInteger BigInteger ">" & "gt" Integer BigInteger ">" & "gt" Long BigInteger ">" & "gt" Short BigInteger ">" & "gt" Byte

    • elBigIntegerGreaterThanEqualTest

      @Test public void elBigIntegerGreaterThanEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBigIntegerGreaterThanEqualTest
      Assertion IDs:
      EL:SPEC:21.1; EL:SPEC:21.5
      Test Strategy:
      Validate that if one of the operands in an EL ">=" or "ge" operation is a BigInteger, the result is coerced to BigInteger and the correct boolean value is returned. Equations tested: BigInteger ">=" & "ge" BigInteger BigInteger ">=" & "ge" Integer BigInteger ">=" & "ge" Long BigInteger ">=" & "ge" Short BigInteger ">=" & "ge" Byte

    • elBigIntegerEqualToTest

      @Test public void elBigIntegerEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBigIntegerEqualToTest
      Assertion IDs:
      EL:SPEC:22.1; EL:SPEC:22.5.1
      Test Strategy:
      Validate that if one of the operands in an EL "==" or "eq" operation is a BigInteger, the result is coerced to BigInteger and the correct boolean value is returned. Equations tested: BigInteger "==" & "eq" BigInteger BigInteger "==" & "eq" Integer BigInteger "==" & "eq" Long BigInteger "==" & "eq" Short BigInteger "==" & "eq" Byte

    • elBigIntegerNotEqualToTest

      @Test public void elBigIntegerNotEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBigIntegerNotEqualToTest
      Assertion IDs:
      EL:SPEC:22.5.2
      Test Strategy:
      Validate that if one of the operands in an EL "!=" or "ne" operation is a BigInteger, the result is coerced to BigInteger and the correct boolean value is returned. Equations tested: BigInteger "!=" & "ne" BigInteger BigInteger "!=" & "ne" Integer BigInteger "!=" & "ne" Long BigInteger "!=" & "ne" Short BigInteger "!=" & "ne" Byte

    • elLongLessThanTest

      @Test public void elLongLessThanTest() throws Exception
      Throws:
      Exception
      Test Name:
      elLongLessThanTest
      Assertion IDs:
      EL:SPEC:21.6
      Test Strategy:
      Validate that if one of the operands in an EL "<" or "lt" operation is a Long, the result is coerced to Long and the correct boolean value is returned. Equations tested: Long "<" & "lt" Integer Long "<" & "lt" Long Long "<" & "lt" Short Long "<" & "lt" Byte

    • elLongLessThanEqualTest

      @Test public void elLongLessThanEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elLongLessThanEqualTest
      Assertion IDs:
      EL:SPEC:21.1; EL:SPEC:21.6
      Test Strategy:
      Validate that if one of the operands in an EL "<=" or "le" operation is a Long, the result is coerced to Long and the correct boolean value is returned. Equations tested: Long "<=" & "le" Integer Long "<=" & "le" Long Long "<=" & "le" Short Long "<=" & "le" Byte

    • elLongGreaterThanTest

      @Test public void elLongGreaterThanTest() throws Exception
      Throws:
      Exception
      Test Name:
      elLongGreaterThanTest
      Assertion IDs:
      EL:SPEC:21.6
      Test Strategy:
      Validate that if one of the operands in an EL ">" or "gt" operation is a Long, the result is coerced to Long and the correct boolean value is returned. Equations tested: Long ">" & "gt" Integer Long ">" & "gt" Long Long ">" & "gt" Short Long ">" & "gt" Byte

    • elLongGreaterThanEqualTest

      @Test public void elLongGreaterThanEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elLongGreaterThanEqualTest
      Assertion IDs:
      EL:SPEC:21.1; EL:SPEC:21.6
      Test Strategy:
      Validate that if one of the operands in an EL ">=" or "ge" operation is a Long, the result is coerced to Long and the correct boolean value is returned. Equations tested: Long ">=" & "ge" Integer Long ">=" & "ge" Long Long ">=" & "ge" Short Long ">=" & "ge" Byte

    • elLongEqualToTest

      @Test public void elLongEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elLongEqualToTest
      Assertion IDs:
      EL:SPEC:22.1; EL:SPEC:22.6
      Test Strategy:
      Validate that if one of the operands in an EL "==" or "eq" operation is a Long, the result is coerced to Long and the correct boolean value is returned. Equations tested: Long "==" & "eq" Integer Long "==" & "eq" Long Long "==" & "eq" Short Long "==" & "eq" Byte

    • elLongNotEqualToTest

      @Test public void elLongNotEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elLongNotEqualToTest
      Assertion IDs:
      EL:SPEC:22.6
      Test Strategy:
      Validate that if one of the operands in an EL "!=" or "ne" operation is a Long, the result is coerced to Long and the correct boolean value is returned. Equations tested: Long "!=" & "ne" Integer Long "!=" & "ne" Long Long "!=" & "ne" Short Long "!=" & "ne" Byte

    • elIntegerLessThanTest

      @Test public void elIntegerLessThanTest() throws Exception
      Throws:
      Exception
      Test Name:
      elIntegerLessThanTest
      Assertion IDs:
      EL:SPEC:21.6
      Test Strategy:
      Validate that if one of the operands in an EL "<" or "lt" operation is an Integer, the result is coerced to Long and the correct boolean value is returned. Equations tested: Integer "<" & "lt" Integer Integer "<" & "lt" Short Integer "<" & "lt" Byte

    • elIntegerLessThanEqualTest

      @Test public void elIntegerLessThanEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elIntegerLessThanEqualTest
      Assertion IDs:
      EL:SPEC:21.1; EL:SPEC:21.6
      Test Strategy:
      Validate that if one of the operands in an EL "<=" or "le" operation is an Integer, the result is coerced to Long and the correct boolean value is returned. Equations tested: Integer "<=" & "le" Integer Integer "<=" & "le" Short Integer "<=" & "le" Byte

    • elIntegerGreaterThanTest

      @Test public void elIntegerGreaterThanTest() throws Exception
      Throws:
      Exception
      Test Name:
      elIntegerGreaterThanTest
      Assertion IDs:
      EL:SPEC:21.6
      Test Strategy:
      Validate that if one of the operands in an EL ">" or "gt" operation is an Integer, the result is coerced to Long and the correct boolean value is returned. Equations tested: Integer ">" & "gt" Integer Integer ">" & "gt" Short Integer ">" & "gt" Byte

    • elIntegerGreaterThanEqualTest

      @Test public void elIntegerGreaterThanEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elIntegerGreaterThanEqualTest
      Assertion IDs:
      EL:SPEC:21.1; EL:SPEC:21.6
      Test Strategy:
      Validate that if one of the operands in an EL ">=" or "ge" operation is an Integer, the result is coerced to Long and the correct boolean value is returned. Equations tested: Integer ">=" & "ge" Integer Integer ">=" & "ge" Short Integer ">=" & "ge" Byte

    • elIntegerEqualToTest

      @Test public void elIntegerEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elIntegerEqualToTest
      Assertion IDs:
      EL:SPEC:22.1; EL:SPEC:22.6
      Test Strategy:
      Validate that if one of the operands in an EL "==" or "eq" operation is an Integer, the result is coerced to Long and the correct boolean value is returned. Equations tested: Integer "==" & "eq" Integer Integer "==" & "eq" Short Integer "==" & "eq" Byte

    • elIntegerNotEqualToTest

      @Test public void elIntegerNotEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elIntegerNotEqualToTest
      Assertion IDs:
      EL:SPEC:22.6
      Test Strategy:
      Validate that if one of the operands in an EL "!=" or "ne" operation is an Integer, the result is coerced to Long and the correct boolean value is returned. Equations tested: Integer "!=" & "ne" Integer Integer "!=" & "ne" Short Integer "!=" & "ne" Byte

    • elShortLessThanTest

      @Test public void elShortLessThanTest() throws Exception
      Throws:
      Exception
      Test Name:
      elShortLessThanTest
      Assertion IDs:
      EL:SPEC:21.6
      Test Strategy:
      Validate that if one of the operands in an EL "<" or "lt" operation is an Short, the result is coerced to Long and the correct boolean value is returned. Equations tested: Short "<" & "lt" Short Short "<" & "lt" Byte

    • elShortLessThanEqualTest

      @Test public void elShortLessThanEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elShortLessThanEqualTest
      Assertion IDs:
      EL:SPEC:21.1; EL:SPEC:21.6
      Test Strategy:
      Validate that if one of the operands in an EL "<=" or "le" operation is an Short, the result is coerced to Long and the correct boolean value is returned. Equations tested: Short "<=" & "le" Short Short "<=" & "le" Byte

    • elShortGreaterThanTest

      @Test public void elShortGreaterThanTest() throws Exception
      Throws:
      Exception
      Test Name:
      elShortGreaterThanTest
      Assertion IDs:
      EL:SPEC:21.6
      Test Strategy:
      Validate that if one of the operands in an EL ">" or "gt" operation is an Short, the result is coerced to Long and the correct boolean value is returned. Equations tested: Short ">" & "gt" Short Short ">" & "gt" Byte

    • elShortGreaterThanEqualTest

      @Test public void elShortGreaterThanEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elShortGreaterThanEqualTest
      Assertion IDs:
      EL:SPEC:21.1; EL:SPEC:21.6
      Test Strategy:
      Validate that if one of the operands in an EL ">=" or "ge" operation is an Short, the result is coerced to Long and the correct boolean value is returned. Equations tested: Short ">=" & "ge" Short Short ">=" & "ge" Byte

    • elShortEqualToTest

      @Test public void elShortEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elShortEqualToTest
      Assertion IDs:
      EL:SPEC:22.1; EL:SPEC:22.6
      Test Strategy:
      Validate that if one of the operands in an EL "==" or "eq" operation is an Short, the result is coerced to Long and the correct boolean value is returned. Equations tested: Short "==" & "eq" Short Short "==" & "eq" Byte

    • elShortNotEqualToTest

      @Test public void elShortNotEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elShortNotEqualToTest
      Assertion IDs:
      EL:SPEC:22.6
      Test Strategy:
      Validate that if one of the operands in an EL "!=" or "ne" operation is an Short, the result is coerced to Long and the correct boolean value is returned. Equations tested: Short "!=" & "ne" Short Short "!=" & "ne" Byte

    • elByteLessThanTest

      @Test public void elByteLessThanTest() throws Exception
      Throws:
      Exception
      Test Name:
      elByteLessThanTest
      Assertion IDs:
      EL:SPEC:21.6
      Test Strategy:
      Validate that if one of the operands in an EL "<" or "lt" operation is an Byte, the result is coerced to Long and the correct boolean value is returned. Equations tested: Byte "<" & "lt" Byte

    • elByteLessThanEqualTest

      @Test public void elByteLessThanEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elByteLessThanEqualTest
      Assertion IDs:
      EL:SPEC:21.1; EL:SPEC:21.6
      Test Strategy:
      Validate that if one of the operands in an EL "<=" or "le" operation is an Byte, the result is coerced to Long and the correct boolean value is returned. Equations tested: Byte "<=" & "le" Byte

    • elByteGreaterThanTest

      @Test public void elByteGreaterThanTest() throws Exception
      Throws:
      Exception
      Test Name:
      elByteGreaterThanTest
      Assertion IDs:
      EL:SPEC:21.1
      Test Strategy:
      Validate that if one of the operands in an EL ">" or "gt" operation is an Byte, the result is coerced to Long and the correct boolean value is returned. Equations tested: Byte ">" & "gt" Byte

    • elByteGreaterThanEqualTest

      @Test public void elByteGreaterThanEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elByteGreaterThanEqualTest
      Assertion IDs:
      EL:SPEC:21.1; EL:SPEC:21.6
      Test Strategy:
      Validate that if one of the operands in an EL ">=" or "ge" operation is an Byte, the result is coerced to Long and the correct boolean value is returned. Equations tested: Byte ">=" & "ge" Byte

    • elByteEqualToTest

      @Test public void elByteEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elByteEqualToTest
      Assertion IDs:
      EL:SPEC:22.1; EL:SPEC:22.6
      Test Strategy:
      Validate that if one of the operands in an EL "==" or "eq" operation is an Byte, the result is coerced to Long and the correct boolean value is returned. Equations tested: Byte "==" & "eq" Byte

    • elByteNotEqualToTest

      @Test public void elByteNotEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elByteNotEqualToTest
      Assertion IDs:
      EL:SPEC:22.6
      Test Strategy:
      Validate that if one of the operands in an EL "!=" or "ne" operation is an Byte, the result is coerced to Long and the correct boolean value is returned. Equations tested: Byte "!=" & "ne" Byte

    • elStringLessThanTest

      @Test public void elStringLessThanTest() throws Exception
      Throws:
      Exception
      Test Name:
      elStringLessThanTest
      Assertion IDs:
      EL:SPEC:21.7
      Test Strategy:
      Validate that if one of the operands in an EL "<" or "lt" operation is an String, that both operands are coerced to type String and the correct boolean value is returned. Equations tested: String "<" & "lt" String

    • elStringLessThanEqualTest

      @Test public void elStringLessThanEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elStringLessThanEqualTest
      Assertion IDs:
      EL:SPEC:21.7
      Test Strategy:
      Validate that if one of the operands in an EL "<=" or "le" operation is a String, that both operands are coerced to type String and the correct boolean value is returned. Equations tested: String "<=" & "le" String

    • elStringGreaterThanTest

      @Test public void elStringGreaterThanTest() throws Exception
      Throws:
      Exception
      Test Name:
      elStringGreaterThanTest
      Assertion IDs:
      EL:SPEC:21.7
      Test Strategy:
      Validate that if one of the operands in an EL ">" or "gt" operation is an String, that both operands are coerced to type String and the correct boolean value is returned. Equations tested: String ">" & "gt" String

    • elStringGreaterThanEqualTest

      @Test public void elStringGreaterThanEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elStringGreaterThanEqualTest
      Assertion IDs:
      EL:SPEC:21.7
      Test Strategy:
      Validate that if one of the operands in an EL ">=" or "ge" operation is an String, that both operands are coerced to type String and the correct boolean value is returned. Equations tested: String ">=" & "ge" String

    • elStringEqualToTest

      @Test public void elStringEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elStringEqualToTest
      Assertion IDs:
      EL:SPEC:22.9
      Test Strategy:
      Validate that if one of the operands in an EL "==" or "eq" operation is an String, that both operands are coerced to type String and the correct boolean value is returned. Equations tested: String "==" & "eq" String

    • elStringNotEqualToTest

      @Test public void elStringNotEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elStringNotEqualToTest
      Assertion IDs:
      EL:SPEC:22.9
      Test Strategy:
      Validate that if one of the operands in an EL "!=" or "ne" operation is an String, that both operands are coerced to type String and the correct boolean value is returned. Equations tested: String "!=" & "ne" String

    • elOtherLessThanTest

      @Test public void elOtherLessThanTest() throws Exception
      Throws:
      Exception
      Test Name:
      elOtherLessThanTest
      Assertion IDs:
      EL:SPEC:21.8.2
      Test Strategy:
      Validate that if operand A in an EL "<" or "lt" operation is comparable, the result A.compareTo(B) is returned. Equation example: DougType "<" & "lt" NickType

    • elOtherLessThanEqualTest

      @Test public void elOtherLessThanEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elOtherLessThanEqualTest
      Assertion IDs:
      EL:SPEC:21.8.2
      Test Strategy:
      Validate that if operand A in an EL "<=" or "le" operation is comparable, the result A.compareTo(B) is returned. Equation example: DougType "<=" & "le" NickType

    • elOtherGreaterThanTest

      @Test public void elOtherGreaterThanTest() throws Exception
      Throws:
      Exception
      Test Name:
      elOtherGreaterThanTest
      Assertion IDs:
      EL:SPEC:21.8.2
      Test Strategy:
      Validate that if operand A in an EL ">" or "gt" operation is comparable, the result A.compareTo(B) is returned. Equation example: DougType "<" & "gt" NickType

    • elOtherGreaterThanEqualTest

      @Test public void elOtherGreaterThanEqualTest() throws Exception
      Throws:
      Exception
      Test Name:
      elOtherGreaterThanEqualTest
      Assertion IDs:
      EL:SPEC:21.8.2
      Test Strategy:
      Validate that if operand A in an EL ">=" or "ge" operation is comparable, the result A.compareTo(B) is returned. Equations tested: DougType ">=" & "ge" NickType

    • elOtherEqualToTest

      @Test public void elOtherEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elOtherEqualToTest
      Assertion IDs:
      EL:SPEC:22.11
      Test Strategy:
      Validate that if operand A in an EL "==" or "eq" operation is comparable, the result A.equals(B) is returned. Equations Example: DougType "==" & "eq" NickType

    • elOtherNotEqualToTest

      @Test public void elOtherNotEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elOtherNotEqualToTest
      Assertion IDs:
      EL:SPEC:22.11
      Test Strategy:
      Validate that if operand A in an EL "!=" or "ne" operation is comparable, the result A.equals(B) is returned. Equation Example: DougType "!=" & "ne" NickType

    • elBooleanEqualToTest

      @Test public void elBooleanEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBooleanEqualToTest
      Assertion IDs:
      EL:SPEC:22.7
      Test Strategy:
      Validate that if one of the operands in an EL "==" or "eq" operation is an Boolean, that both operands are coerced to type Boolean and the correct boolean value is returned. Equations tested: Boolean "==" & "eq" String

    • elBooleanNotEqualToTest

      @Test public void elBooleanNotEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBooleanNotEqualToTest
      Assertion IDs:
      EL:SPEC:22.7
      Test Strategy:
      Validate that if one of the operands in an EL "!=" or "ne" operation is an Boolean, that both operands are coerced to type Boolean and the correct boolean value is returned. Equations tested: String "!=" & "ne" String

    • elEnumEqualToTest

      @Test public void elEnumEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elEnumEqualToTest
      Assertion IDs:
      EL:SPEC:22.8
      Test Strategy:
      Validate that if one of the operands in an EL "==" or "eq" operation is an Enum, that both operands are coerced to type Enum and the correct boolean value is returned. Example Equation: Enum "==" String or Integer

    • elEnumNotEqualToTest

      @Test public void elEnumNotEqualToTest() throws Exception
      Throws:
      Exception
      Test Name:
      elEnumNotEqualToTest
      Assertion IDs:
      EL:SPEC:22.8
      Test Strategy:
      Validate that if one of the operands in an EL "!=" or "ne" operation is an Enum, that both operands are coerced to type String and the correct boolean value is returned. Example Equation: Enum "!=" & "ne" Enum