XOMTestCase (XOM 1.2.4 API)
Date: 2009-12-11

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## nu.xom.tests
Class XOMTestCase

    Object
      junit.framework.Assert
          junit.framework.TestCase
              nu.xom.tests.XOMTestCase

All Implemented Interfaces:
  Test

    public class XOMTestCase

extends TestCase

Provides utility methods to compare nodes for deep equality in an infoset sense.

Version:
  1.1a2
Author:
  Elliotte Rusty Harold

Constructor Summary
`XOMTestCase(String name)` Create a new `XOMTestCase` with the specified name.

Method Summary
`static void` | `assertEquals(Attribute expected, Attribute actual)` Asserts that two attribute nodes are equal.
`static void` | `assertEquals(Comment expected, Comment actual)` Asserts that two comment nodes are equal.
`static void` | `assertEquals(DocType expected, DocType actual)` Asserts that two `DocType` nodes are equal.
`static void` | `assertEquals(Document expected, Document actual)` Asserts that two document nodes are equal.
`static void` | `assertEquals(Element expected, Element actual)` Asserts that two element nodes are equal.
`static void` | `assertEquals(Node expected, Node actual)` Asserts that two nodes are equal.
`static void` | `assertEquals(ProcessingInstruction expected, ProcessingInstruction actual)` Asserts that two processing instruction nodes are equal.
`static void` | `assertEquals(String message, Attribute expected, Attribute actual)` Asserts that two attribute nodes are equal.
`static void` | `assertEquals(String message, Comment expected, Comment actual)` Asserts that two comment nodes are equal.
`static void` | `assertEquals(String message, DocType expected, DocType actual)` Asserts that two `DocType` nodes are equal.
`static void` | `assertEquals(String message, Document expected, Document actual)` Asserts that two document nodes are equal.
`static void` | `assertEquals(String message, Element expected, Element actual)` Asserts that two element nodes are equal.
`static void` | `assertEquals(String message, Namespace expected, Namespace actual)` Asserts that two namespace nodes are equal.
`static void` | `assertEquals(String message, Node expected, Node actual)` Asserts that two nodes are equal.
`static void` | `assertEquals(String message, ProcessingInstruction expected, ProcessingInstruction actual)` Asserts that two processing instruction nodes are equal.
`static void` | `assertEquals(String message, Text expected, Text actual)` Asserts that two text nodes are equal.
`static void` | `assertEquals(Text expected, Text actual)` Asserts that two text nodes are equal.

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`

Methods inherited from class Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Constructor Detail

### XOMTestCase

    public XOMTestCase(String name)

  Create a new `XOMTestCase` with the specified name.

Method Detail

### assertEquals

    public static void assertEquals(Text expected,
                                    Text actual)

  Asserts that two text nodes are equal. Text nodes are considered equal if they are identical char by char, or if both are null. Unicode and whitespace normalization is not performed before comparison. If the two nodes are not equal, a `ComparisonFailure` is thrown.

  Parameters:
    `expected` - the text the test should produce
    `actual` - the text the test does produce
  Throws:
    `ComparisonFailure` - if the text nodes are not equal

### assertEquals

    public static void assertEquals(String message,
                                    Text expected,
                                    Text actual)

  Asserts that two text nodes are equal. Text nodes are considered equal if they are identical char by char, or if both are null. Unicode and whitespace normalization is not performed before comparison. If the two nodes are not equal, a `ComparisonFailure` is thrown with the given message.

  Parameters:
    `message` - printed if the texts are not equal
    `expected` - the text the test should produce
    `actual` - the text the test does produce
  Throws:
    `ComparisonFailure` - if the text nodes are not equal

### assertEquals

    public static void assertEquals(Attribute expected,
                                    Attribute actual)

  Asserts that two attribute nodes are equal. Attribute nodes are considered equal if their qualified names, namespace URIs, and values are equal. The type is not considered because it tends not to survive a roundtrip. If the two nodes are not equal, a `ComparisonFailure` is thrown.

  There is special handling for the `xml:base` attribute. In order to facilitate comparison between relative and absolute URIs, two `xml:base` attributes are considered equal if one might be a relative form of the other.

  Parameters:
    `expected` - the attribute the test should produce
    `actual` - the attribute the test does produce
  Throws:
    `ComparisonFailure` - if the sttributes are not equal

### assertEquals

    public static void assertEquals(String message,
                                    Attribute expected,
                                    Attribute actual)

  Asserts that two attribute nodes are equal. Attribute nodes are considered equal if their qualified names, namespace URIs, and values are equal. The type is not considered because this tends not to survive a roundtrip. If the two nodes are not equal, a `ComparisonFailure` is thrown with the given message.

  There is special handling for the `xml:base` attribute. In order to facilitate comparison between relative and absolute URIs, two `xml:base` attributes are considered equal if one might be a relative form of the other.

  Parameters:
    `message` - printed if the attributes are not equal
    `expected` - the attribute the test should produce
    `actual` - the attribute the test does produce
  Throws:
    `ComparisonFailure` - if the attributes are not equal

### assertEquals

    public static void assertEquals(DocType expected,
                                    DocType actual)

  Asserts that two `DocType` nodes are equal. `DocType` nodes are considered equal if their root element names, public IDs, and system IDs are equal. The internal DTD subsets are not considered. If the two nodes are not equal, a `ComparisonFailure` is thrown.

  Parameters:
    `expected` - the DOCTYPE declaration the test should produce
    `actual` - the DOCTYPE declaration the test does produce
  Throws:
    `ComparisonFailure` - if the document type declarations are not equal

### assertEquals

    public static void assertEquals(String message,
                                    DocType expected,
                                    DocType actual)

  Asserts that two `DocType` nodes are equal. `DocType` nodes are considered equal if their root element name, public ID, and system ID are equal. The internal DTD subsets are not considered. If the two nodes are not equal, a `ComparisonFailure` is thrown with the given message.

  Parameters:
    `message` - printed if the DOCTYPE declarations are not equal
    `expected` - the DOCTYPE declaration the test should produce
    `actual` - the DOCTYPE declaration the test does produce
  Throws:
    `ComparisonFailure` - if the document type declarations are not equal

### assertEquals

    public static void assertEquals(Element expected,
                                    Element actual)

  Asserts that two element nodes are equal. Element nodes are considered equal if their qualified names, namespace URI, attributes, declared namespaces, and children are equal. Consecutive text node children are coalesced before the comparison is made. If the two nodes are not equal, a `ComparisonFailure` is thrown.

  Parameters:
    `expected` - the element the test should produce
    `actual` - the element the test does produce
  Throws:
    `ComparisonFailure` - if the elements are not equal

### assertEquals

    public static void assertEquals(String message,
                                    Element expected,
                                    Element actual)

  Asserts that two element nodes are equal. Element nodes are considered equal if their qualified names, namespace URI, attributes, declared namespaces, and children are equal. Consecutive text node children are coalesced before the comparison is made. Empty text nodes are removed. If the two nodes are not equal, a `ComparisonFailure` is thrown with the given message.

  Parameters:
    `message` - printed if the elements are not equal
    `expected` - the element the test should produce
    `actual` - the element the test does produce
  Throws:
    `ComparisonFailure` - if the elements are not equal

### assertEquals

    public static void assertEquals(Document expected,
                                    Document actual)

  Asserts that two document nodes are equal. Document nodes are considered equal if their children are equal. If the two nodes are not equal, a `ComparisonFailure` is thrown.

  Parameters:
    `expected` - the document the test should produce
    `actual` - the document the test does produce
  Throws:
    `ComparisonFailure` - if the documents are not equal

### assertEquals

    public static void assertEquals(String message,
                                    Document expected,
                                    Document actual)

  Asserts that two document nodes are equal. Document nodes are considered equal if their children are equal. If the two nodes are not equal, a `ComparisonFailure` is thrown with the given message.

  Parameters:
    `message` - printed if the documents are not equal
    `expected` - the document the test should produce
    `actual` - the document the test does produce
  Throws:
    `ComparisonFailure` - if the documents are not equal

### assertEquals

    public static void assertEquals(Comment expected,
                                    Comment actual)

  Asserts that two comment nodes are equal. Comment nodes are considered equal if they are identical char by char, or if both are null. Unicode and whitespace normalization is not performed before comparison. If the two nodes are not equal, a `ComparisonFailure` is thrown.

  Parameters:
    `expected` - the comment the test should produce
    `actual` - the comment the test does produce
  Throws:
    `ComparisonFailure` - if the comments are not equal

### assertEquals

    public static void assertEquals(String message,
                                    Comment expected,
                                    Comment actual)

  Asserts that two comment nodes are equal. Comment nodes are considered equal if they are identical char by char, or if both are null. Unicode and whitespace normalization is not performed before comparison. If the two nodes are not equal, a `ComparisonFailure` is thrown with the given message.

  Parameters:
    `message` - printed if the comments are not equal
    `expected` - the comment the test should produce
    `actual` - the comment the test does produce
  Throws:
    `ComparisonFailure` - if the comments are not equal

### assertEquals

    public static void assertEquals(ProcessingInstruction expected,
                                    ProcessingInstruction actual)

  Asserts that two processing instruction nodes are equal. Processing instruction nodes are considered equal if they have the same target and the same value. If the two nodes are not equal, a `ComparisonFailure` is thrown.

  Parameters:
    `expected` - the processing instruction the test should produce
    `actual` - the processing instruction the test does produce
  Throws:
    `ComparisonFailure` - if the processing instructions are not equal

### assertEquals

    public static void assertEquals(String message,
                                    ProcessingInstruction expected,
                                    ProcessingInstruction actual)

  Asserts that two processing instruction nodes are equal. Processing instruction nodes are considered equal if they have the same target and the same value. If the two nodes are not equal, a `ComparisonFailure` is thrown with the given message.

  Parameters:
    `message` - printed if the processing instructions are not equal
    `expected` - the processing instruction the test should produce
    `actual` - the processing instruction the test does produce
  Throws:
    `ComparisonFailure` - if the processing instructions are not equal

### assertEquals

    public static void assertEquals(String message,
                                    Namespace expected,
                                    Namespace actual)

  Asserts that two namespace nodes are equal. Namespace nodes are considered equal if they have the same prefix and the same URI. If the two nodes are not equal, a `ComparisonFailure` is thrown with the given message.

  Parameters:
    `message` - printed if the namespaces are not equal
    `expected` - the namespace the test should produce
    `actual` - the namespace the test does produce
  Throws:
    `ComparisonFailure` - if the namespaces are not equal

### assertEquals

    public static void assertEquals(Node expected,
                                    Node actual)

  Asserts that two nodes are equal. If the two nodes are not equal a `ComparisonFailure` is thrown. The subclass is not considered. The basic XOM class is considered, but the subclass is not. For example, a `Text` object can be equal to an object that is an `HTMLText`, but it can never be equal to a `Comment`.

  Parameters:
    `expected` - the node the test should produce
    `actual` - the node the test does produce
  Throws:
    `ComparisonFailure` - if the nodes are not equal

### assertEquals

    public static void assertEquals(String message,
                                    Node expected,
                                    Node actual)

  Asserts that two nodes are equal. If the two nodes are not equal a `ComparisonFailure` is thrown with the given message. The subclass is not considered. The basic XOM class is considered, but the subclass is not. For example, a `Text` object can be equal to an an `HTMLText` object, but it can never be equal to a `Comment`.

  Parameters:
    `message` - printed if the nodes are not equal
    `expected` - the node the test should produce
    `actual` - the node the test does produce
  Throws:
    `ComparisonFailure` - if the nodes are not equal

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright 2002-2009 Elliotte Rusty Harold
elharo@ibiblio.org