Package ee.jakarta.tck.el.spec.binaryoperator

Class ELClientIT

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

  • Constructor Details

    • ELClientIT

      public ELClientIT()

  • Method Details

    • cleanup

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

    • elNullOperandAddTest

      @Test public void elNullOperandAddTest() throws Exception
      Throws:
      Exception
      Test Name:
      elNullOperandAddTest
      Assertion IDs:
      EL:SPEC:17.1
      Test Strategy:
      Validate that if both of the operands in an EL "+" (addition) operation are null, the result is (Long) 0.

    • elNullOperandSubtractTest

      @Test public void elNullOperandSubtractTest() throws Exception
      Throws:
      Exception
      Test Name:
      elNullOperandSubtractTest
      Assertion IDs:
      EL:SPEC:17.1
      Test Strategy:
      Validate that if both of the operands in an EL "-" (subtraction) operation are null, the result is (Long) 0.

    • elNullOperandMultiplyTest

      @Test public void elNullOperandMultiplyTest() throws Exception
      Throws:
      Exception
      Test Name:
      elNullOperandMultiplyTest
      Assertion IDs:
      EL:SPEC:17.1
      Test Strategy:
      Validate that if both of the operands in an EL "*" (multiplication) operation are null, the result is (Long) 0.

    • elNullOperandDivisionTest

      @Test public void elNullOperandDivisionTest() throws Exception
      Throws:
      Exception
      Test Name:
      elNullOperandDivisionTest
      Assertion IDs:
      EL:SPEC:18.1
      Test Strategy:
      Validate that if both of the operands in an EL "/" (division) operation are null, the result is (Long) 0.

    • elNullOperandModulusTest

      @Test public void elNullOperandModulusTest() throws Exception
      Throws:
      Exception
      Test Name:
      elNullOperandModulusTest
      Assertion IDs:
      EL:SPEC:19.1
      Test Strategy:
      Validate that if both of the operands in an EL "%" (mod) operation are null, the result is (Long) 0.

    • elBigDecimalAddTest

      @Test public void elBigDecimalAddTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBigDecimalAddTest
      Assertion IDs:
      EL:SPEC:17.2.1
      Test Strategy:
      Validate that if one of the operands in an EL "+" (addition) operation is a BigDecimal, the result is coerced to BigDecimal and is the sum of the operands. Equations tested: BigDecimal + BigDecimal BigDecimal + Double BigDecimal + Float BigDecimal + String containing ".", "e", or "E" BigDecimal + BigInteger BigDecimal + Integer BigDecimal + Long BigDecimal + Short BigDecimal + Byte

    • elBigDecimalSubtractTest

      @Test public void elBigDecimalSubtractTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBigDecimalSubtractTest
      Assertion IDs:
      EL:SPEC:17.2.2
      Test Strategy:
      Validate that if one of the operands in an EL "-" (subtraction) operation is a BigDecimal, the result is coerced to BigDecimal and is the difference of the operands. Equations tested: BigDecimal - BigDecimal BigDecimal - Double BigDecimal - Float BigDecimal - String containing ".", "e", or "E" BigDecimal - BigInteger BigDecimal - Integer BigDecimal - Long BigDecimal - Short BigDecimal - Byte

    • elBigDecimalMultiplyTest

      @Test public void elBigDecimalMultiplyTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBigDecimalMultiplyTest
      Assertion IDs:
      EL:SPEC:17.2.3
      Test Strategy:
      Validate that if one of the operands in an EL "*" (multiplication) operation is a BigDecimal, the result is coerced to BigDecimal and is the product of the operands. Equations tested: BigDecimal * BigDecimal BigDecimal * Double BigDecimal * Float BigDecimal * String containing ".", "e", or "E" BigDecimal * BigInteger BigDecimal * Integer BigDecimal * Long BigDecimal * Short BigDecimal * Byte

    • elBigDecimalDivisionTest

      @Test public void elBigDecimalDivisionTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBigDecimalDivisionTest
      Assertion IDs:
      EL:SPEC:18.2
      Test Strategy:
      Validate that if one of the operands in an EL "/" (div) operation is a BigDecimal, the result is coerced to BigDecimal and is the quotient of the operands. Equations tested: BigDecimal / BigDecimal BigDecimal / Double BigDecimal / Float BigDecimal / String containing ".", "e", or "E" BigDecimal / BigInteger BigDecimal / Integer BigDecimal / Long BigDecimal / Short BigDecimal / Byte

    • elBigDecimalModulusTest

      @Test public void elBigDecimalModulusTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBigDecimalModulusTest
      Assertion IDs:
      EL:SPEC:19.2
      Test Strategy:
      Validate that if one of the operands in an EL "%" (mod) operation is a BigDecimal, the result is coerced to Double and is the remainder of the quotient of the operands. Equations tested: BigDecimal % BigDecimal BigDecimal % Double BigDecimal % Float BigDecimal % String containing ".", "e", or "E" BigDecimal % BigInteger BigDecimal % Integer BigDecimal % Long BigDecimal % Short BigDecimal % Byte

    • elBigIntegerAddTest

      @Test public void elBigIntegerAddTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBigIntegerAddTest
      Assertion IDs:
      EL:SPEC:17.4.1
      Test Strategy:
      Validate that if one of the operands in an EL "+" (addition) operation is a BigInteger, the result is coerced to BigInteger and is the sum of the operands. Equations tested: BigInteger + BigInteger BigInteger + Integer BigInteger + Long BigInteger + Short BigInteger + Byte

    • elBigIntegerSubtractTest

      @Test public void elBigIntegerSubtractTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBigIntegerSubtractTest
      Assertion IDs:
      EL:SPEC:17.4.2
      Test Strategy:
      Validate that if one of the operands in an EL "-" (subtraction) operation is a BigInteger, the result is coerced to BigInteger and is the difference of the operands. Equations tested: BigInteger - BigInteger BigInteger - Integer BigInteger - Long BigInteger - Short BigInteger - Byte

    • elBigIntegerMultiplyTest

      @Test public void elBigIntegerMultiplyTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBigIntegerMultiplyTest
      Assertion IDs:
      EL:SPEC:17.4.3
      Test Strategy:
      Validate that if one of the operands in an EL "*" operation is a BigInteger, the result is coerced to BigInteger and is the product of the operands. BigInteger * BigInteger BigInteger * Integer BigInteger * Long BigInteger * Short BigInteger * Byte

    • elBigIntegerDivisionTest

      @Test public void elBigIntegerDivisionTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBigIntegerDivisionTest
      Assertion IDs:
      EL:SPEC:18.2
      Test Strategy:
      Validate that if one of the operands in an EL "/" (div) operation is a BigInteger, the result is coerced to BigDecimal and is the quotient of the operands. BigInteger / BigInteger BigInteger / Integer BigInteger / Long BigInteger / Short BigInteger / Byte

    • elBigIntegerModulusTest

      @Test public void elBigIntegerModulusTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBigIntegerModulusTest
      Assertion IDs:
      EL:SPEC:19.3
      Test Strategy:
      Validate that if one of the operands in an EL "%" (mod) operation is a BigInteger, the result is coerced to BigInteger and is the remainder of the quotient of the operands. BigInteger % BigInteger BigInteger % Integer BigInteger % Long BigInteger % Short BigInteger % Byte

    • elFloatAddTest

      @Test public void elFloatAddTest() throws Exception
      Throws:
      Exception
      Test Name:
      elFloatAddTest
      Assertion IDs:
      EL:SPEC:17.3.1; EL:SPEC:17.3.2
      Test Strategy:
      Validate that if one of the operands in an EL "+" (addition) operation is a Float, the result is coerced to Double and is the sum of the operands. Equations tested: Float + Double Float + Float Float + String containing ".", "e", or "E" Float + BigInteger Float + Integer Float + Long Float + Short Float + Byte

    • elFloatSubtractTest

      @Test public void elFloatSubtractTest() throws Exception
      Throws:
      Exception
      Test Name:
      elFloatSubtractTest
      Assertion IDs:
      EL:SPEC:17.3.1; EL:SPEC:17.3.2
      Test Strategy:
      Validate that if one of the operands in an EL "-" (subtraction) operation is a Float, the result is coerced to Double and is the difference of the operands. Equations tested: Float - Double Float - Float Float - String containing ".", "e", or "E" Float - BigInteger Float - Integer Float - Long Float - Short Float - Byte

    • elFloatMultiplyTest

      @Test public void elFloatMultiplyTest() throws Exception
      Throws:
      Exception
      Test Name:
      elFloatMultiplyTest
      Assertion IDs:
      EL:SPEC:17.3.1; EL:SPEC:17.3.2
      Test Strategy:
      Validate that if one of the operands in an EL "*" (multiplication) operation is a Float, the result is coerced to Double and is the product of the operands. Equations tested: Float * Double Float * Float Float * String containing ".", "e", or "E" Float * BigInteger Float * Integer Float * Long Float * Short Float * Byte

    • elFloatDivisionTest

      @Test public void elFloatDivisionTest() throws Exception
      Throws:
      Exception
      Test Name:
      elFloatDivisionTest
      Assertion IDs:
      EL:SPEC:18.2; EL:SPEC:18.3
      Test Strategy:
      Validate that if one of the operands in an EL "/" (div) operation is a Float, the result is coerced to Double and is the quotient of the operands. Equations tested: Float / Double Float / Float Float / String containing ".", "e", or "E" Float / BigInteger Float / Integer Float / Long Float / Short Float / Byte

    • elFloatModulusTest

      @Test public void elFloatModulusTest() throws Exception
      Throws:
      Exception
      Test Name:
      elFloatModulusTest
      Assertion IDs:
      EL:SPEC:19.2
      Test Strategy:
      Validate that if one of the operands in an EL "%" (mod) operation is a Float, the result is coerced to Double and is the remainder of the quotient of the operands. Equations tested: Float % Double Float % Float Float % String containing ".", "e", or "E" Float % BigInteger Float % Integer Float % Long Float % Short Float % Byte

    • elDoubleAddTest

      @Test public void elDoubleAddTest() throws Exception
      Throws:
      Exception
      Test Name:
      elDoubleAddTest
      Assertion IDs:
      EL:SPEC:17.3.1; EL:SPEC:17.3.2
      Test Strategy:
      Validate that if one of the operands in an EL "+" (addition) operation is a Double, the result is coerced to Double and is the sum of the operands. Equations tested: Double + Double Double + String containing ".", "e", or "E" Double + BigInteger Double + Integer Double + Long Double + Short Double + Byte

    • elDoubleSubtractTest

      @Test public void elDoubleSubtractTest() throws Exception
      Throws:
      Exception
      Test Name:
      elDoubleSubtractTest
      Assertion IDs:
      EL:SPEC:17.3.1; EL:SPEC:17.3.2
      Test Strategy:
      Validate that if one of the operands in an EL "-" (subtraction) operation is a Double, the result is coerced to Double and is the difference of the operands. Equations tested: Double - Double Double - String containing ".", "e", or "E" Double - BigInteger Double - Integer Double - Long Double - Short Double - Byte

    • elDoubleMultiplyTest

      @Test public void elDoubleMultiplyTest() throws Exception
      Throws:
      Exception
      Test Name:
      elDoubleMultiplyTest
      Assertion IDs:
      EL:SPEC:17.3.1; EL:SPEC:17.3.2
      Test Strategy:
      Validate that if one of the operands in an EL "*" (multiplication) operation is a Double, the result is coerced to Double and is the product of the operands. Equations tested: Double * Double Double * String containing ".", "e", or "E" Double * BigInteger Double * Integer Double * Long Double * Short Double * Byte

    • elDoubleDivisionTest

      @Test public void elDoubleDivisionTest() throws Exception
      Throws:
      Exception
      Test Name:
      elDoubleDivisionTest
      Assertion IDs:
      EL:SPEC:18.2; EL:SPEC:18.3
      Test Strategy:
      Validate that if one of the operands in an EL "/" (div) operation is a Double, the result is coerced to Double and is the quotient of the operands. Equations tested: Double / Double Double / String containing ".", "e", or "E" Double / BigInteger Double / Integer Double / Long Double / Short Double / Byte

    • elDoubleModulusTest

      @Test public void elDoubleModulusTest() throws Exception
      Throws:
      Exception
      Test Name:
      elDoubleModulusTest
      Assertion IDs:
      EL:SPEC:19.2
      Test Strategy:
      Validate that if one of the operands in an EL "%" (mod) operation is a Double, the result is coerced to Double and is the remainder of the quotient of the operands. Equations tested: Double % Double Double % String containing ".", "e", or "E" Double % BigInteger Double % Integer Double % Long Double % Short Double % Byte

    • elNumericStringSubtractTest

      @Test public void elNumericStringSubtractTest() throws Exception
      Throws:
      Exception
      Test Name:
      elNumericStringSubtractTest
      Assertion IDs:
      EL:SPEC:17.3.1; EL:SPEC:17.3.2
      Test Strategy:
      Validate that if one of the operands in an EL "-" (subtraction) operation is a numeric string, the result is coerced to Double and is the difference of the operands. Equations tested: Numeric String - String containing ".", "e", or "E" Numeric String - BigInteger Numeric String - Integer Numeric String - Long Numeric String - Short Numeric String - Byte

    • elNumericStringMultiplyTest

      @Test public void elNumericStringMultiplyTest() throws Exception
      Throws:
      Exception
      Test Name:
      elNumericStringMultiplyTest
      Assertion IDs:
      EL:SPEC:17.3.1; EL:SPEC:17.3.2
      Test Strategy:
      Validate that if one of the operands in an EL "*" (multiplication) operation is a numeric string, the result is coerced to Double and is the product of the operands. Equations tested: Numeric String * String containing ".", "e", or "E" Numeric String * BigInteger Numeric String * Integer Numeric String * Long Numeric String * Short Numeric String * Byte

    • elNumericStringDivisionTest

      @Test public void elNumericStringDivisionTest() throws Exception
      Throws:
      Exception
      Test Name:
      elNumericStringDivisionTest
      Assertion IDs:
      EL:SPEC:18.2; EL:SPEC:18.3
      Test Strategy:
      Validate that if one of the operands in an EL "/" (div) operation is a numeric string, the result is coerced to Double and is the quotient of the operands. Equations tested: Numeric String / String containing ".", "e", or "E" Numeric String / BigInteger Numeric String / Integer Numeric String / Long Numeric String / Short Numeric String / Byte

    • elNumericStringModulusTest

      @Test public void elNumericStringModulusTest() throws Exception
      Throws:
      Exception
      Test Name:
      elNumericStringModulusTest
      Assertion IDs:
      EL:SPEC:19.2
      Test Strategy:
      Validate that if one of the operands in an EL "%" (mod) operation is a numeric string, the result is coerced to Double and is the remainder of the quotient of the operands. Equations tested: Numeric String % String containing ".", "e", or "E" Numeric String % BigInteger Numeric String % Integer Numeric String % Long Numeric String % Short Numeric String % Byte

    • elLongAddTest

      @Test public void elLongAddTest() throws Exception
      Throws:
      Exception
      Test Name:
      elLongAddTest
      Assertion IDs:
      EL:SPEC:17.5
      Test Strategy:
      Validate that if one of the operands in an EL "+" (addition) operation is a Long, the result is coerced to Long and is the sum of the operands. Equations tested: Long + Integer Long + Long Long + Short Long + Byte

    • elLongSubtractTest

      @Test public void elLongSubtractTest() throws Exception
      Throws:
      Exception
      Test Name:
      elLongSubtractTest
      Assertion IDs:
      EL:SPEC:17.5
      Test Strategy:
      Validate that if one of the operands in an EL "-" (subtraction) operation is a Long, the result is coerced to Long and is the difference of the operands. Equations tested: Long - Integer Long - Long Long - Short Long - Byte

    • elLongMultiplyTest

      @Test public void elLongMultiplyTest() throws Exception
      Throws:
      Exception
      Test Name:
      elLongMultiplyTest
      Assertion IDs:
      EL:SPEC:17.5
      Test Strategy:
      Validate that if one of the operands in an EL "*" (multiplication) operation is a Long, the result is coerced to Long and is the product of the operands. Equations tested: Long * Integer Long * Long Long * Short Long * Byte

    • elLongDivisionTest

      @Test public void elLongDivisionTest() throws Exception
      Throws:
      Exception
      Test Name:
      elLongDivisionTest
      Assertion IDs:
      EL:SPEC:18.3
      Test Strategy:
      Validate that if one of the operands in an EL "/" (div) operation is a Long, the result is coerced to Double and is the quotient of the operands. Equations tested: Long / Integer Long / Long Long / Short Long / Byte

    • elLongModulusTest

      @Test public void elLongModulusTest() throws Exception
      Throws:
      Exception
      Test Name:
      elLongModulusTest
      Assertion IDs:
      EL:SPEC:19.4
      Test Strategy:
      Validate that if one of the operands in an EL "%" (mod) operation is a Long, the result is coerced to Long and is the remainder of the quotient of the operands. Equations tested: Long % Integer Long % Long Long % Short Long % Byte

    • elIntegerAddTest

      @Test public void elIntegerAddTest() throws Exception
      Throws:
      Exception
      Test Name:
      elIntegerAddTest
      Assertion IDs:
      EL:SPEC:17.5
      Test Strategy:
      Validate that if one of the operands in an EL "+" (addition) operation is a Integer, the result is coerced to Long and is the sum of the operands. Equations tested: Integer + Integer Integer + Short Integer + Byte

    • elIntegerSubtractTest

      @Test public void elIntegerSubtractTest() throws Exception
      Throws:
      Exception
      Test Name:
      elIntegerSubtractTest
      Assertion IDs:
      EL:SPEC:17.5
      Test Strategy:
      Validate that if one of the operands in an EL "-" (subtraction) operation is a Integer, the result is coerced to Long and is the difference of the operands. Equations tested: Long - Integer Long - Short Long - Byte

    • elIntegerMultiplyTest

      @Test public void elIntegerMultiplyTest() throws Exception
      Throws:
      Exception
      Test Name:
      elIntegerMultiplyTest
      Assertion IDs:
      EL:SPEC:17.5
      Test Strategy:
      Validate that if one of the operands in an EL "*" (multiplication) operation is a Integer, the result is coerced to Long and is the product of the operands. Equations tested: Integer * Integer Integer * Short Integer * Byte

    • elIntegerDivisionTest

      @Test public void elIntegerDivisionTest() throws Exception
      Throws:
      Exception
      Test Name:
      elIntegerDivisionTest
      Assertion IDs:
      EL:SPEC:18.3
      Test Strategy:
      Validate that if one of the operands in an EL "/" (div) operation is a Integer, the result is coerced to Double and is the quotient of the operands. Equations tested: Integer / Integer Integer / Short Integer / Byte

    • elIntegerModulusTest

      @Test public void elIntegerModulusTest() throws Exception
      Throws:
      Exception
      Test Name:
      elIntegerModulusTest
      Assertion IDs:
      EL:SPEC:19.4
      Test Strategy:
      Validate that if one of the operands in an EL "%" (mod) operation is a Integer, the result is coerced to Long and is the remainder of the quotient of the operands. Equations tested: Integer % Integer Integer % Short Integer % Byte

    • elShortAddTest

      @Test public void elShortAddTest() throws Exception
      Throws:
      Exception
      Test Name:
      elShortAddTest
      Assertion IDs:
      EL:SPEC:17.5
      Test Strategy:
      Validate that if one of the operands in an EL "+" (addition) operation is a Short, the result is coerced to Long and is the sum of the operands. Equations tested: Short + Short Short + Byte

    • elShortSubtractTest

      @Test public void elShortSubtractTest() throws Exception
      Throws:
      Exception
      Test Name:
      elShortSubtractTest
      Assertion IDs:
      EL:SPEC:17.5
      Test Strategy:
      Validate that if one of the operands in an EL "-" (subtraction) operation is a Short, the result is coerced to Long and is the difference of the operands. Equations tested: Short - Short Short - Byte

    • elShortMultiplyTest

      @Test public void elShortMultiplyTest() throws Exception
      Throws:
      Exception
      Test Name:
      elShortMultiplyTest
      Assertion IDs:
      EL:SPEC:17.5
      Test Strategy:
      Validate that if one of the operands in an EL "*" (multiplication) operation is a Short, the result is coerced to Long and is the product of the operands. Equations tested: Short * Short Short * Byte

    • elShortDivisionTest

      @Test public void elShortDivisionTest() throws Exception
      Throws:
      Exception
      Test Name:
      elShortDivisionTest
      Assertion IDs:
      EL:SPEC:18.3
      Test Strategy:
      Validate that if one of the operands in an EL "/" (div) operation is a Short, the result is coerced to Double and is the quotient of the operands. Equations tested: Short / Short Short / Byte

    • elShortModulusTest

      @Test public void elShortModulusTest() throws Exception
      Throws:
      Exception
      Test Name:
      elShortModulusTest
      Assertion IDs:
      EL:SPEC:19.4
      Test Strategy:
      Validate that if one of the operands in an EL "%" (mod) operation is a Short, the result is coerced to Long and is the remainder of the quotient of the operands. Equations tested: Short % Short Short % Byte

    • elByteAddTest

      @Test public void elByteAddTest() throws Exception
      Throws:
      Exception
      Test Name:
      elByteAddTest
      Assertion IDs:
      EL:SPEC:17.5
      Test Strategy:
      Validate that if both operands in an EL "+" (addition) operation are Bytes, the result is coerced to Long and is the sum of the operands. Equations tested: Byte + Byte

    • elByteSubtractTest

      @Test public void elByteSubtractTest() throws Exception
      Throws:
      Exception
      Test Name:
      elByteSubtractTest
      Assertion IDs:
      EL:SPEC:17.5
      Test Strategy:
      Validate that if both operands in an EL "-" (subtraction) operation are Bytes, the result is coerced to Long and is the difference of the operands. Equations tested: Byte - Byte

    • elByteMultiplyTest

      @Test public void elByteMultiplyTest() throws Exception
      Throws:
      Exception
      Test Name:
      elByteMultiplyTest
      Assertion IDs:
      EL:SPEC:17.5
      Test Strategy:
      Validate that if both operands in an EL "*" (multiplication) operation are Bytes, the result is coerced to Long and is the product of the operands. Equations tested: Byte * Byte

    • elByteDivisionTest

      @Test public void elByteDivisionTest() throws Exception
      Throws:
      Exception
      Test Name:
      elByteDivisionTest
      Assertion IDs:
      EL:SPEC:18.3
      Test Strategy:
      Validate that if both operands in an EL "/" (div) operation are Bytes, the result is coerced to Double and is the quotient of the operands. Equations tested: Byte / Byte

    • elByteModulusTest

      @Test public void elByteModulusTest() throws Exception
      Throws:
      Exception
      Test Name:
      elByteModulusTest
      Assertion IDs:
      EL:SPEC:19.4
      Test Strategy:
      Validate that if both operands in an EL "%" (mod) operation are Bytes, the result is coerced to Long and is the remainder of the quotient of the operands. Equations tested: Byte % Byte

    • elBooleanAndTest

      @Test public void elBooleanAndTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBooleanAndTest
      Assertion IDs:
      EL:SPEC:23.1; EL:SPEC:24.2.1
      Test Strategy:
      Validate that if one of the operands in an EL "&&", "and" operation is a Boolean, the result is coerced to Boolean. Equations tested: Boolean && String Boolean && Boolean Boolean and String Boolean and Boolean

    • elBooleanOrTest

      @Test public void elBooleanOrTest() throws Exception
      Throws:
      Exception
      Test Name:
      elBooleanOrTest
      Assertion IDs:
      EL:SPEC:23.1; EL:SPEC:24.2.1
      Test Strategy:
      Validate that if one of the operands in an EL "||", "or" operation is a Boolean, the result is coerced to Boolean. Equations tested: Boolean || String Boolean || Boolean Boolean or String Boolean or Boolean