com.singularsys.jeptests.system

## Class ExtendedParserTest

- java.lang.Object
- - com.singularsys.jeptests.system.JepTest
  - - com.singularsys.jeptests.system.ExtendedParserTest

-     public class ExtendedParserTest
      extends JepTest

  Tests for modification to the configurable parser. Including adding new operators.
  See Also:
    `JavaOperatorTable`

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `ExtendedParserTest.InOperators`

  - ### Field Summary

    - ### Fields inherited from class com.singularsys.jeptests.system.JepTest

      `jep, myFalse, myTrue, PRINT_RESULTS`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ExtendedParserTest()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `setUp()` Sets up the parser.
    `void` | `test2010_03_01()`
    `void` | `testAlternateSymbols()` Tests for other symbols used.
    `void` | `testBitwise()`
    `void` | `testComplex()` Not implemented here
    `void` | `testElementOf()` Tests operators and functions which test if an element is in array or list.
    `void` | `testFactorial()` Test the suffix factorial operation
    `void` | `testFunction()` Not implemented here
    `void` | `testIfThenElse()`
    `void` | `testIncrement()`
    `void` | `testLazyLogical()` Not implemented here
    `void` | `testLazyLogical2()`
    `void` | `testLazyLogicalBug()` Test for bug with 1&&1&&1
    `void` | `testLogical()` Not implemented here
    `void` | `testNoComplex()`
    `void` | `testNumberAsBooleanLogical()`
    `void` | `testNumParam()` Not implemented here
    `void` | `testOpEquals()`
    `void` | `testOverlappingNames()` Tests if we have a conflict between OR and ORGANIZE
    `void` | `testParseException()` Tests whether a parse exceptions are thrown when they should be.
    `void` | `testPercent()` Tests the suffix % operation
    `void` | `testPlusPlus()` Not implemented here
    `void` | `testRealConfig()`
    `void` | `testSingleArgFun()` Tests mathematical style "cos pi" functions without brackets.
    `void` | `testStrings()` Not implemented here
    `void` | `testSuffix()` Test a combination of suffix operations
    `void` | `testTernary()`
    `void` | `testToBase()` Test the various type conversion functions.
    `void` | `testUpperCaseOperator()` Tests case-intensative operator names AND, And, and.
    `void` | `testX2Y()` Not implemented here

    - ### Methods inherited from class com.singularsys.jeptests.system.JepTest

      `assertEqNodes, buildMatrix, buildVector, calcValue, calcValue, checkVector, compareRecursive, complexValueTest, myAssertEquals, myAssertNaN, myAssertNull, negativeZero, nodeTest, nodeTest, nodeTest, nodeTest, printTestHeader, testAssign, testBinom, testBlankParser, testCaseNull, testCaseString, testChangeVariable, testChangeVariableComplex, testComments, testEmptyEqn, testEmptyEqn2, testEvalExceptions, testEvaluate, testEvaluateComplex, testEvaluateString, testExpectedTokenSequence, testFormat, testIf, testImplicitMul, testListAccess, testListExtra, testListFunctions, testLogarithm, testMacroFunction, testMultiDimArray, testMultiLine, testMultiplyBug, testNaN, testNoAssign, testNull, testNumbers, testRecursiveMacroFunction, testSemiColon, testSetAllowUndeclared, testSimpleSum, testSpecialFunctions, testSpecialFunctions, testStringsFun, testSwitch, testUminusPower, valueTest, valueTest, valueTestFail, valueTestNaN, valueTestNull, valueTestString`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### ExtendedParserTest

          public ExtendedParserTest()

  - ### Method Detail

    - #### setUp

          public void setUp()

      Description copied from class: `JepTest`
      Sets up the parser.
      Overrides:
        `setUp` in class `JepTest`

    - #### testBitwise

          public void testBitwise()
                           throws java.lang.Exception

      Throws:
        `java.lang.Exception`

    - #### testTernary

          public void testTernary()
                           throws java.lang.Exception

      Throws:
        `java.lang.Exception`

    - #### testComplex

          public void testComplex()
                           throws java.lang.Exception

      Not implemented here
      Overrides:
        `testComplex` in class `JepTest`
      Throws:
        `java.lang.Exception`

    - #### testFunction

          public void testFunction()
                            throws java.lang.Exception

      Not implemented here
      Overrides:
        `testFunction` in class `JepTest`
      Throws:
        `java.lang.Exception`

    - #### testPlusPlus

          public void testPlusPlus()
                            throws java.lang.Exception

      Not implemented here
      Overrides:
        `testPlusPlus` in class `JepTest`
      Throws:
        `java.lang.Exception`

    - #### testIncrement

          public void testIncrement()
                             throws java.lang.Exception

      Throws:
        `java.lang.Exception`

    - #### testOpEquals

          public void testOpEquals()
                            throws java.lang.Exception

      Throws:
        `java.lang.Exception`

    - #### testLogical

          public void testLogical()
                           throws java.lang.Exception

      Not implemented here
      Overrides:
        `testLogical` in class `JepTest`
      Throws:
        `java.lang.Exception`

    - #### testNumberAsBooleanLogical

          public void testNumberAsBooleanLogical()
                                          throws java.lang.Exception

      Overrides:
        `testNumberAsBooleanLogical` in class `JepTest`
      Throws:
        `java.lang.Exception`

    - #### testLazyLogical

          public void testLazyLogical()
                               throws java.lang.Exception

      Not implemented here
      Overrides:
        `testLazyLogical` in class `JepTest`
      Throws:
        `java.lang.Exception`

    - #### testLazyLogical2

          public void testLazyLogical2()
                                throws java.lang.Exception

      Overrides:
        `testLazyLogical2` in class `JepTest`
      Throws:
        `java.lang.Exception`

    - #### testNumParam

          public void testNumParam()
                            throws java.lang.Exception

      Not implemented here
      Overrides:
        `testNumParam` in class `JepTest`
      Throws:
        `java.lang.Exception`

    - #### testX2Y

          public void testX2Y()
                       throws java.lang.Exception

      Not implemented here
      Overrides:
        `testX2Y` in class `JepTest`
      Throws:
        `java.lang.Exception`

    - #### testStrings

          public void testStrings()
                           throws java.lang.Exception

      Not implemented here
      Overrides:
        `testStrings` in class `JepTest`
      Throws:
        `java.lang.Exception`

    - #### testUpperCaseOperator

          public void testUpperCaseOperator()
                                     throws java.lang.Exception

      Tests case-intensative operator names AND, And, and.
      Throws:
        `java.lang.Exception`

    - #### testParseException

          public void testParseException()

      Description copied from class: `JepTest`
      Tests whether a parse exceptions are thrown when they should be. See ticket #50 Tests on both the standard parser and the configurable parser, is carried out by CPTest which extends this.
      Overrides:
        `testParseException` in class `JepTest`

    - #### testIfThenElse

          public void testIfThenElse()
                              throws java.lang.Exception

      Throws:
        `java.lang.Exception`

    - #### testOverlappingNames

          public void testOverlappingNames()
                                    throws java.lang.Exception

      Tests if we have a conflict between OR and ORGANIZE
      Throws:
        `java.lang.Exception`

    - #### test2010_03_01

          public void test2010_03_01()
                              throws java.lang.Exception

      Throws:
        `java.lang.Exception`

    - #### testLazyLogicalBug

          public void testLazyLogicalBug()
                                  throws java.lang.Exception

      Description copied from class: `JepTest`
      Test for bug with 1&&1&&1
      Overrides:
        `testLazyLogicalBug` in class `JepTest`
      Throws:
        `java.lang.Exception`

    - #### testElementOf

          public void testElementOf()
                             throws java.lang.Exception

      Tests operators and functions which test if an element is in array or list.
      Throws:
        `java.lang.Exception`
      See Also:
        `ElementOf`

    - #### testToBase

          public void testToBase()
                          throws java.lang.Exception

      Test the various type conversion functions.
      Throws:
        `java.lang.Exception`
      See Also:
        `ToBase`, `FromBase`

    - #### testPercent

          public void testPercent()
                           throws java.lang.Exception

      Tests the suffix % operation
      Throws:
        `java.lang.Exception`
      See Also:
        `ExtendedOperatorSet`

    - #### testFactorial

          public void testFactorial()
                             throws java.lang.Exception

      Test the suffix factorial operation
      Throws:
        `java.lang.Exception`
      See Also:
        `Factorial`

    - #### testSuffix

          public void testSuffix()
                          throws java.lang.Exception

      Test a combination of suffix operations
      Throws:
        `java.lang.Exception`

    - #### testAlternateSymbols

          public void testAlternateSymbols()
                                    throws java.lang.Exception

      Tests for other symbols used. Minus sign is actually unicode U+2013
      Throws:
        `java.lang.Exception`

    - #### testSingleArgFun

          public void testSingleArgFun()
                                throws java.lang.Exception

      Tests mathematical style "cos pi" functions without brackets.
      Throws:
        `java.lang.Exception`
      See Also:
        `SingleArgFunctionMatcher`

    - #### testNoComplex

          public void testNoComplex()
                             throws JepException

      Throws:
        `JepException`

    - #### testRealConfig

          public void testRealConfig()
                              throws JepException

      Throws:
        `JepException`

Copyright © 2018 Singular Systems http://www.singularsys.com/jep