uk.ac.starlink.util

## Class TestCase

- java.lang.Object
- - junit.framework.Assert
  - - junit.framework.TestCase
    - - uk.ac.starlink.util.TestCase

- All Implemented Interfaces:
    junit.framework.Test

      public class TestCase
      extends junit.framework.TestCase

  This class extends `TestCase`, providing some additional assertions and methods for providing test data for convenience. All the existing methods of `TestCase` are simply delegated to the superclass.

  Some of the methods are concerned with providing random values; these are deterministic in that the random seed is set to a fixed value when the test case is initialised, so a given test should always be working with the same data, though the same call twice in a given test will provide different random data.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static short` | `IGNORE_ATTRIBUTE_PRESENCE` Flags for `assertDOMEquals(java.net.URL, org.w3c.dom.Node)`
    `static short` | `IGNORE_ATTRIBUTE_VALUE`
    `static short` | `IGNORE_COMMENTS`
    `static short` | `IGNORE_WHITESPACE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `TestCase()` No-arg constructor.
    `TestCase(java.lang.String name)` Constructs a test case with the given name.

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `assertArrayEquals(java.lang.Object expected, java.lang.Object actual)` Asserts that two arrays have exactly the same contents.
    `void` | `assertArrayEquals(java.lang.Object expected, java.lang.Object actual, double delta)` Asserts that two numeric arrays have the same contents within a given tolerance.
    `void` | `assertArrayEquals(java.lang.String message, java.lang.Object expected, java.lang.Object actual)` Asserts that two arrays have exactly the same contents.
    `void` | `assertArrayEquals(java.lang.String message, java.lang.Object expected, java.lang.Object actual, double delta)` Asserts that two numeric arrays have the same contents within a given tolerance.
    `void` | `assertArrayNotEquals(java.lang.Object expected, java.lang.Object actual)` Asserts that two objects are not arrays with the same contents.
    `void` | `assertArrayNotEquals(java.lang.Object expected, java.lang.Object actual, double delta)` Asserts that two objects are not numeric arrays having the same contents within a given tolerance.
    `void` | `assertArrayNotEquals(java.lang.String message, java.lang.Object expected, java.lang.Object actual)` Asserts that two objects are not arrays with the same contents.
    `void` | `assertArrayNotEquals(java.lang.String message, java.lang.Object expected, java.lang.Object actual, double delta)` Asserts that two objects are not numeric arrays having the same contents within a given tolerance.
    `void` | `assertDOMEquals(java.io.InputStream s, org.w3c.dom.Node actual, java.lang.String context, int flags)` Asserts that a DOM is equivalent to the DOM read from a given stream.
    `void` | `assertDOMEquals(org.w3c.dom.Node expected, org.w3c.dom.Node actual)` Asserts that two DOMs are equal.
    `void` | `assertDOMEquals(org.w3c.dom.Node expected, org.w3c.dom.Node actual, java.lang.String context, int flags)` Asserts that two DOMs are equal.
    `void` | `assertDOMEquals(java.lang.String s, org.w3c.dom.Node n)` Asserts that a DOM is equivalent to the DOM implied by the XML in a given string.
    `void` | `assertDOMEquals(java.lang.String expected, org.w3c.dom.Node actual, java.lang.String context, int flags)` Asserts that a DOM is equivalent to the DOM implied by the XML in a given string.
    `void` | `assertDOMEquals(java.net.URL url, org.w3c.dom.Node actual)` Asserts that a DOM is equivalent to the XML in a given URL.
    `void` | `assertDOMEquals(java.net.URL url, org.w3c.dom.Node actual, java.lang.String context, int flags)` Asserts that a DOM is equivalent to the XML in a given URL.
    `void` | `assertEquals(double expected, double actual)` Asserts that two `double`s are exactly equal.
    `void` | `assertEquals(float expected, float actual)` Asserts that two `float`s are exactly equal.
    `void` | `assertEquals(java.lang.String message, double expected, double actual)` Asserts that two `double`s are exactly equal.
    `void` | `assertEquals(java.lang.String message, float expected, float actual)` Asserts that two `float`s are exactly equal.
    `void` | `assertSourceEquals(javax.xml.transform.Source expected, javax.xml.transform.Source actual, java.lang.String context, int flags)` Asserts that two XML `Source` objects represent the same XML Infoset.
    `void` | `assertValidXML(org.xml.sax.InputSource isrc)` Asserts that the contents of a stream are valid XML.
    `void` | `assertValidXML(java.lang.String message, org.xml.sax.InputSource isrc)` Asserts that the contents of a stream are valid XML.
    `void` | `fillCycle(java.lang.Object array, int min, int max)` Fills a given array with a regular pattern of integer values.
    `void` | `fillCycle(java.lang.Object destArray, java.lang.Object sourceArray)` Fills a given array with a pattern of values taken from another one.
    `void` | `fillRandom(java.lang.Object array, double min, double max)` Fills a given array with random numbers between two floating point values.
    `void` | `fillRandom(java.lang.Object array, int min, int max)` Fills a given array with random numbers between two integer values.
    `static int` | `getJavaMajorVersion()` Returns the java major version number.
    `static boolean` | `isHeadless()` Tests whether or not a display, keyboard and mouse can in fact be supported in this environment.

    - ### Methods inherited from class junit.framework.TestCase

      `countTestCases, createResult, getName, run, run, runBare, runTest, setName, setUp, tearDown, toString`

    - ### Methods inherited from class junit.framework.Assert

      `assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertFalse, assertFalse, assertNotNull, assertNotNull, assertNotSame, assertNotSame, assertNull, assertNull, assertSame, assertSame, assertTrue, assertTrue, fail, fail, failNotEquals, failNotSame, failSame`

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

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

- - ### Field Detail

    - #### IGNORE_ATTRIBUTE_PRESENCE

          public static final short IGNORE_ATTRIBUTE_PRESENCE

      Flags for `assertDOMEquals(java.net.URL, org.w3c.dom.Node)`
      See Also:
        Constant Field Values

    - #### IGNORE_ATTRIBUTE_VALUE

          public static final short IGNORE_ATTRIBUTE_VALUE

      See Also:
        Constant Field Values

    - #### IGNORE_WHITESPACE

          public static final short IGNORE_WHITESPACE

      See Also:
        Constant Field Values

    - #### IGNORE_COMMENTS

          public static final short IGNORE_COMMENTS

      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### TestCase

          public TestCase()

      No-arg constructor.

    - #### TestCase

          public TestCase(java.lang.String name)

      Constructs a test case with the given name.
      Parameters:
        `name` - test case name

  - ### Method Detail

    - #### assertArrayEquals

          public void assertArrayEquals(java.lang.String message,
                                        java.lang.Object expected,
                                        java.lang.Object actual)

      Asserts that two arrays have exactly the same contents. For the assertion to be true, `expected` and `actual` must both be array objects whose component types are of the same class; they must have the same number of elements; and the ith element of `expected` must be `equal' to the ith element of `actual`. `Equality' in this sense depends on the types of the arrays: if they are arrays of a primitive type, the primitive values must be equal, and if they are object arrays equality is assessed using the `Object.equals(java.lang.Object)` method. In the case of `float[]` and `double[]` arrays, elements which both have the value `NaN` are taken to match.
      Parameters:
        `message` - the message to output if the assertion fails
        `expected` - the expected array object
        `actual` - the actual array object
      Throws:
        `junit.framework.AssertionFailedError` - if the assertion is untrue

    - #### assertArrayNotEquals

          public void assertArrayNotEquals(java.lang.String message,
                                           java.lang.Object expected,
                                           java.lang.Object actual)

      Asserts that two objects are not arrays with the same contents. This assertion has exactly the opposite sense to that of `assertArrayEquals(String,Object,Object)`.
      Parameters:
        `message` - the message to output if the assertion fails
        `expected` - the expected array object
        `actual` - the actual array object, asserted not to match `expected`
      Throws:
        `junit.framework.AssertionFailedError` - if the assertion is untrue

    - #### assertArrayEquals

          public void assertArrayEquals(java.lang.Object expected,
                                        java.lang.Object actual)

      Asserts that two arrays have exactly the same contents. For the assertion to be true, `expected` and `actual` must both be array objects whose component types are of the same class; they must have the same number of elements; and the ith element of `expected` must be `equal' to the ith element of `actual`. `Equality' in this sense depends on the types of the arrays: if they are arrays of a primitive type, the primitive values must be equal, and if they are object arrays equality is assessed using the `Object.equals(java.lang.Object)` method. In the case of `float[]` and `double[]` arrays, elements which both have the value `NaN` are taken to match.
      Parameters:
        `expected` - the expected array object
        `actual` - the actual array object
      Throws:
        `junit.framework.AssertionFailedError` - if the assertion is untrue

    - #### assertArrayNotEquals

          public void assertArrayNotEquals(java.lang.Object expected,
                                           java.lang.Object actual)

      Asserts that two objects are not arrays with the same contents. This assertion has exactly the opposite sense to that of `assertArrayEquals(Object,Object)`.
      Parameters:
        `expected` - the expected array object
        `actual` - the actual array object, asserted not to match `expected`
      Throws:
        `junit.framework.AssertionFailedError` - if the assertion is untrue

    - #### assertArrayEquals

          public void assertArrayEquals(java.lang.String message,
                                        java.lang.Object expected,
                                        java.lang.Object actual,
                                        double delta)

      Asserts that two numeric arrays have the same contents within a given tolerance. For the assertion to be true, `expected` and `actual` must both be primitive numeric array objects whose component types are of the same class; they must have the same number of elements; and the ith element of `expected` must be `equal' to the ith element of `actual`. Equality in this sense normally means `(abs(expected[i]-actual[i]<delta)`, but in the case of `float[]` and `double[]` arrays, elements which both have the value `NaN` are taken to match, and if the expected element is infinite, then `delta` is ignored.

      If `delta<1` and the arrays are of integer type, this method does the same as `assertArrayEquals(String,Object,Object)`.

      Parameters:
        `message` - the message to output if the assertion fails
        `expected` - the array object containing the expected values
        `actual` - the array object containing the actual values
        `delta` - the tolerance acceptable between values
      Throws:
        `junit.framework.AssertionFailedError` - if the assertion is untrue

    - #### assertArrayNotEquals

          public void assertArrayNotEquals(java.lang.String message,
                                           java.lang.Object expected,
                                           java.lang.Object actual,
                                           double delta)

      Asserts that two objects are not numeric arrays having the same contents within a given tolerance. This assertion has exactly the opposite sense to that of `assertArrayEquals(String,Object,Object,double)`.
      Parameters:
        `message` - the message to output if the assertion fails
        `expected` - the array object containing the expected values
        `actual` - the array object containing the actual values, asserted not to match `expected`
        `delta` - the tolerance acceptable between values
      Throws:
        `junit.framework.AssertionFailedError` - if the assertion is untrue

    - #### assertArrayEquals

          public void assertArrayEquals(java.lang.Object expected,
                                        java.lang.Object actual,
                                        double delta)

      Asserts that two numeric arrays have the same contents within a given tolerance. For the assertion to be true, `expected` and `actual` must both be primitive numeric array objects whose component types are of the same class; they must have the same number of elements; and the ith element of `expected` must be `equal' to the ith element of `actual`. Equality in this sense normally means `(abs(expected[i]-actual[i]<delta)`, but in the case of `float[]` and `double[]` arrays, elements which both have the value `NaN` are taken to match, and if the expected element is infinite, then `delta` is ignored.

      If `delta<1` and the arrays are of integer type, this method does the same as `assertArrayEquals(Object,Object)`.

      Parameters:
        `expected` - the array object containing the expected values
        `actual` - the array object containing the actual values
        `delta` - the tolerance acceptable between values
      Throws:
        `junit.framework.AssertionFailedError` - if the assertion is untrue

    - #### assertArrayNotEquals

          public void assertArrayNotEquals(java.lang.Object expected,
                                           java.lang.Object actual,
                                           double delta)

      Asserts that two objects are not numeric arrays having the same contents within a given tolerance. This assertion has exactly the opposite sense to that of `assertArrayEquals(Object,Object,double)`.
      Parameters:
        `expected` - the array object containing the expected values
        `actual` - the array object containing the actual values, asserted not to match `expected`
        `delta` - the tolerance acceptable between values
      Throws:
        `junit.framework.AssertionFailedError` - if the assertion is untrue

    - #### assertEquals

          public void assertEquals(java.lang.String message,
                                   float expected,
                                   float actual)

      Asserts that two `float`s are exactly equal.
      Parameters:
        `message` - the message to output if the assertion fails
        `expected` - the expected value
        `actual` - the actual value
      Throws:
        `junit.framework.AssertionFailedError` - if the assertion is untrue

    - #### assertEquals

          public void assertEquals(float expected,
                                   float actual)

      Asserts that two `float`s are exactly equal.
      Parameters:
        `expected` - the expected value
        `actual` - the actual value
      Throws:
        `junit.framework.AssertionFailedError` - if the assertion is untrue

    - #### assertEquals

          public void assertEquals(java.lang.String message,
                                   double expected,
                                   double actual)

      Asserts that two `double`s are exactly equal.
      Parameters:
        `message` - the message to output if the assertion fails
        `expected` - the expected value
        `actual` - the actual value
      Throws:
        `junit.framework.AssertionFailedError` - if the assertion is untrue

    - #### assertEquals

          public void assertEquals(double expected,
                                   double actual)

      Asserts that two `double`s are exactly equal.
      Parameters:
        `expected` - the expected value
        `actual` - the actual value
      Throws:
        `junit.framework.AssertionFailedError` - if the assertion is untrue

    - #### assertDOMEquals

          public void assertDOMEquals(java.net.URL url,
                                      org.w3c.dom.Node actual)
                               throws java.io.IOException,
                                      org.xml.sax.SAXException,
                                      javax.xml.parsers.ParserConfigurationException

      Asserts that a DOM is equivalent to the XML in a given URL. Equivalent to `assertDOMEquals(dom, actual, filename, 0)` with the first argument being the document element of the DOM read from the URL, and the third argument being the last part (the `file name') of the URL.
      Parameters:
        `url` - pointing to an XML file -- the document element of this file is the expected value
        `actual` - the node which is being compared
      Throws:
        `java.io.IOException` - if the file cannot be found
        `org.xml.sax.SAXException` - if there is a problem parsing the XML
        `javax.xml.parsers.ParserConfigurationException` - if the XML parser cannot be initialised
        `junit.framework.AssertionFailedError` - if the assertion is untrue
      See Also:
        `assertDOMEquals(Node,Node,String,int)`

    - #### assertDOMEquals

          public void assertDOMEquals(java.net.URL url,
                                      org.w3c.dom.Node actual,
                                      java.lang.String context,
                                      int flags)
                               throws java.io.IOException,
                                      org.xml.sax.SAXException,
                                      javax.xml.parsers.ParserConfigurationException

      Asserts that a DOM is equivalent to the XML in a given URL. Equivalent to `assertDOMEquals(dom, actual, context, flags)` with the first argument being the document element of the DOM read from the URL, and the third argument being the last part (the `file name') of the URL.
      Parameters:
        `url` - pointing to an XML file -- the document element of this file is the expected value
        `actual` - the node which is being compared
        `context` - a string indicating the context of this; if `null`, it defaults to `string:'
        `flags` - a set of flags controlling the comparison; see `assertDOMEquals(Node,Node,String,int)`
      Throws:
        `java.io.IOException` - if the file cannot be found
        `org.xml.sax.SAXException` - if there is a problem parsing the XML
        `javax.xml.parsers.ParserConfigurationException` - if the XML parser cannot be initialised
        `junit.framework.AssertionFailedError` - if the assertion is untrue
      See Also:
        `assertDOMEquals(Node,Node,String,int)`

    - #### assertDOMEquals

          public void assertDOMEquals(java.lang.String s,
                                      org.w3c.dom.Node n)
                               throws java.io.IOException,
                                      org.xml.sax.SAXException,
                                      javax.xml.parsers.ParserConfigurationException

      Asserts that a DOM is equivalent to the DOM implied by the XML in a given string.
      Throws:
        `java.io.IOException`
        `org.xml.sax.SAXException`
        `javax.xml.parsers.ParserConfigurationException`
      See Also:
        `assertDOMEquals(String,Node,String,int)`

    - #### assertDOMEquals

          public void assertDOMEquals(java.lang.String expected,
                                      org.w3c.dom.Node actual,
                                      java.lang.String context,
                                      int flags)
                               throws java.io.IOException,
                                      org.xml.sax.SAXException,
                                      javax.xml.parsers.ParserConfigurationException

      Asserts that a DOM is equivalent to the DOM implied by the XML in a given string.
      Parameters:
        `expected` - a string containing XML -- the document element of this file is the expected value
        `actual` - the node which is compared
        `context` - a string indicating the context of this; if `null`, it defaults to `string:'
        `flags` - a set of flags controlling the comparison; see `assertDOMEquals(Node,Node,String,int)`
      Throws:
        `junit.framework.AssertionFailedError` - if the assertion is untrue
        `java.io.IOException`
        `org.xml.sax.SAXException`
        `javax.xml.parsers.ParserConfigurationException`
      See Also:
        `assertDOMEquals(Node,Node,String,int)`

    - #### assertDOMEquals

          public void assertDOMEquals(java.io.InputStream s,
                                      org.w3c.dom.Node actual,
                                      java.lang.String context,
                                      int flags)
                               throws java.io.IOException,
                                      org.xml.sax.SAXException,
                                      javax.xml.parsers.ParserConfigurationException

      Asserts that a DOM is equivalent to the DOM read from a given stream.
      Parameters:
        `s` - a stream from which XML may be read -- the document element of the resulting DOM is the expected value
        `actual` - the node which is compared
        `context` - a string indicating the context of this; may be `null`
        `flags` - a set of flags controlling the comparison; see `assertDOMEquals(Node,Node,String,int)`
      Throws:
        `junit.framework.AssertionFailedError` - if the assertion is untrue
        `java.io.IOException`
        `org.xml.sax.SAXException`
        `javax.xml.parsers.ParserConfigurationException`
      See Also:
        `assertDOMEquals(Node,Node,String,int)`

    - #### assertDOMEquals

          public void assertDOMEquals(org.w3c.dom.Node expected,
                                      org.w3c.dom.Node actual)

      Asserts that two DOMs are equal.
      Parameters:
        `expected` - the Node containing the expected DOM
        `actual` - the Node to be tested
      Throws:
        `junit.framework.AssertionFailedError` - if the assertion is untrue
      See Also:
        `assertDOMEquals(Node,Node,String,int)`

    - #### assertSourceEquals

          public void assertSourceEquals(javax.xml.transform.Source expected,
                                         javax.xml.transform.Source actual,
                                         java.lang.String context,
                                         int flags)

      Asserts that two XML `Source` objects represent the same XML Infoset. Differences in whitespace and in comments may optionally be ignored.
      Parameters:
        `expected` - the Source object containing the expected infoset
        `actual` - the Source object containing the actual infoset, asserted to match `expected`
        `context` - a string indicating the context of this; may be `null`
        `flags` - a set of flags indicating which node tests to omit. Passing as zero includes all tests.
      Throws:
        `junit.framework.AssertionFailedError` - if the assertion is untrue
      See Also:
        `assertDOMEquals(Node,Node,String,int)`

    - #### assertDOMEquals

          public void assertDOMEquals(org.w3c.dom.Node expected,
                                      org.w3c.dom.Node actual,
                                      java.lang.String context,
                                      int flags)

      Asserts that two DOMs are equal.

      If an assertion fails, the method indicates the location by showing in the failure message the location of the mismatched node, so that

           AssertionFailedError: .../test.xml:/[1]ndx/[2]data
           expected: ...

      indicates that the assertion failed when examining the second child node (which was a `<data>` element) of the first child of the file `test.xml`

      If the `flags` argument is non-zero, it indicates a set of tests on the DOM to omit. The value is ORed together from the following constants:

      `TestCase.IGNORE_ATTRIBUTE_PRESENCE`
      do not check whether attributes match
      `TestCase.IGNORE_ATTRIBUTE_VALUE`
        check that the same attributes are present on the corresponding elements in the tree, but do not check their values
      `TestCase.IGNORE_WHITESPACE`
        skip whitespace-only text nodes
      `TestCase.IGNORE_COMMENTS`
        skip comment nodes
      Parameters:
        `expected` - the Node containing the expected DOM
        `actual` - the Node to be tested
        `context` - a string indicating the context, which will be used in assertion failure reports. May be null
        `flags` - a set of flags indicating which node tests to omit. Passing as zero includes all tests.
      Throws:
        `junit.framework.AssertionFailedError` - if the assertion is untrue

    - #### assertValidXML

          public void assertValidXML(java.lang.String message,
                                     org.xml.sax.InputSource isrc)
                              throws java.io.IOException,
                                     org.xml.sax.SAXException

      Asserts that the contents of a stream are valid XML. The stream is passed through a validating XML parser. Badly-formed XML, or failure to conform to any DTD or schema referenced in the document's declaration will result in a SAXParseException.

      Entity resolution is done using an instance of `StarEntityResolver`.

      Parameters:
        `message` - message associated with assertion failure
        `isrc` - input source containing an XML document
      Throws:
        `java.io.IOException` - if there is an error reading `strm`
        `org.xml.sax.SAXException` - if the document in `strm` is badly-formed or invalid

    - #### assertValidXML

          public void assertValidXML(org.xml.sax.InputSource isrc)
                              throws java.io.IOException,
                                     org.xml.sax.SAXException

      Asserts that the contents of a stream are valid XML. The stream is passed through a validating XML parser. Badly-formed XML, or failure to conform to any DTD or schema referenced in the document's declaration will result in a SAXParseException.
      Parameters:
        `isrc` - input stream containing an XML document
      Throws:
        `java.io.IOException` - if there is an error reading `strm`
        `org.xml.sax.SAXException` - if the document in `strm` is badly-formed or invalid

    - #### fillRandom

          public void fillRandom(java.lang.Object array,
                                 double min,
                                 double max)

      Fills a given array with random numbers between two floating point values. If the supplied minimum and maximum values are outside the range appropriate for the primitive type in question the range will be suitably clipped.
      Parameters:
        `array` - an array of primitives to be filled with random values
        `min` - the smallest value which will be used (will be converted to the appropriate primitive type)
        `max` - the largest value which will be used (will be converted to the appropriate primitive type)
      Throws:
        `java.lang.IllegalArgumentException` - if `array` is not an array of a suitable primitive type

    - #### fillRandom

          public void fillRandom(java.lang.Object array,
                                 int min,
                                 int max)

      Fills a given array with random numbers between two integer values. If the supplied minimum and maximum values are outside the range appropriate for the primitive type in question the range will be suitably clipped.
      Parameters:
        `array` - an array of primitives to be filled with random values
        `min` - the smallest value which will be used (will be converted to the appropriate primitive type)
        `max` - the largest value which will be used (will be converted to the appropriate primitive type)
      Throws:
        `java.lang.IllegalArgumentException` - if `array` is not an array of a suitable primitive type

    - #### fillCycle

          public void fillCycle(java.lang.Object array,
                                int min,
                                int max)

      Fills a given array with a regular pattern of integer values. The elements of the array will take the values `min, min+1, min+2 .. max-1, min, min+1, min+2..` and so on. If the `max<min` then the values will start at `min` and keep increasing.

      The results might not be as expected if you use a `min` and `max` values outside the range of the numeric type in question.

      Parameters:
        `array` - an array of primitives to be filled with cycling values
        `min` - the first value
        `max` - the highest value, or if less than `min` an indication that there is no maximum
      Throws:
        `java.lang.IllegalArgumentException` - if `array` is not an array of a suitable primitive type

    - #### fillCycle

          public void fillCycle(java.lang.Object destArray,
                                java.lang.Object sourceArray)

      Fills a given array with a pattern of values taken from another one. `destArray` is filled up with copies of `sourceArray`. `destArray` and `sourceArray` must be arrays of the same class (but can be different lengths of course).
      Parameters:
        `destArray` - array to be filled with items
        `sourceArray` - array containing source items

    - #### isHeadless

          public static boolean isHeadless()

      Tests whether or not a display, keyboard and mouse can in fact be supported in this environment. This differs from the `GraphicsEnvironment.isHeadless()` method in that this one tries to do some graphics and if it catches a throwable as a consequence it will return true. The only time that the `GraphicsEnvironment` call returns true in practice is if you start java with the property `java.awt.headless=true`.
      Returns:
        `true` if graphics type stuff will fail

    - #### getJavaMajorVersion

          public static int getJavaMajorVersion()

      Returns the java major version number. This shouldn't fail, but surprising aspects of the runtime environment might cause an exception; I consider that OK for a method that will only execute during unit tests.
      Returns:
        java major version number; 1.8 is returned as 8