w3c/domts/DOMTestCase.java

/*
 * Copyright (c) 2001-2004 World Wide Web Consortium, (Massachusetts Institute
 * of Technology, Institut National de Recherche en Informatique et en
 * Automatique, Keio University). All Rights Reserved. This program is
 * distributed under the W3C's Software Intellectual Property License. This
 * program is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See W3C License
 * http://www.w3.org/Consortium/Legal/ for more details.
 */

package org.w3c.domts;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Iterator;

import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.NodeList;

/**
 * This is an abstract base class for generated DOM tests
 */
public abstract class DOMTestCase
    extends DOMTest {
  private DOMTestFramework framework;

  /**
   * This constructor is for DOMTestCase's that make specific demands for
   * parser configuration. setFactory should be called before the end of the
   * tests constructor to set the factory.
   */
  public DOMTestCase() {
    framework = null;
  }

  /**
   * This constructor is for DOMTestCase's that do not add any requirements
   * for parser configuration.
   *
   * @param factory
   *            document factory to be used by test, may not be null.
   */
  public DOMTestCase(DOMTestDocumentBuilderFactory factory) {
    super(factory);
    framework = null;
  }

  /**
   * This method is called by the main() for each test and locates the
   * appropriate test framework and runs the specified test
   *
   * @param testClass
   *            test class
   * @param args
   *            arguments to test class
   */
  public static void doMain(Class testClass, String[] args) {
    //
    //   Attempt to load JUnitRunner
    //
    ClassLoader loader = ClassLoader.getSystemClassLoader();
    try {
      Class runnerClass = loader.loadClass("org.w3c.domts.JUnitRunner");
      Constructor runnerFactory =
          runnerClass.getConstructor(new Class[] {Class.class});
      //
      //   create the JUnitRunner
      //
      Object junitRun =
          runnerFactory.newInstance(new Object[] {testClass});
      //
      //   find and call its execute method method
      //
      Class argsClass = loader.loadClass("[Ljava.lang.String;");
      Method execMethod =
          runnerClass.getMethod("execute", new Class[] {argsClass});
      execMethod.invoke(junitRun, new Object[] {args});
    }
    catch (InvocationTargetException ex) {
      ex.getTargetException().printStackTrace();
    }
    catch (Exception ex) {
      System.out.println(
          "junit-run.jar and junit.jar \n must be in same directory or on classpath.");
      ex.printStackTrace();
    }
  }

  /**
   * Body of test
   *
   * @throws Throwable
   */
  abstract public void runTest() throws Throwable;

  /**
   * Sets test framework to be used by test.
   *
   * @param framework
   */
  public void setFramework(DOMTestFramework framework) {
    this.framework = framework;
  }

  /**
   * Wait
   *
   * @param millisecond
   *            milliseconds to wait
   */
  public void wait(int millisecond) {
    framework.wait(millisecond);
  }

  /**
   * Fail test
   *
   * @param assertID
   *            identifier of assertion
   */
  public void fail(String assertID) {
    framework.fail(this, assertID);
  }

  /**
   * Asserts that actual==true
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   */
  public void assertTrue(String assertID, boolean actual) {
    framework.assertTrue(this, assertID, actual);
  }

  /**
   * Asserts that actual==true
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   */
  public void assertTrue(String assertID, Object actual) {
    framework.assertTrue(this, assertID, ( (Boolean) actual).booleanValue());
  }

  /**
   * Asserts that actual==false
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   */
  public void assertFalse(String assertID, boolean actual) {
    framework.assertFalse(this, assertID, actual);
  }

  /**
   * Asserts that actual==false
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   */
  public void assertFalse(String assertID, Object actual) {
    framework.assertFalse(
        this,
        assertID,
        ( (Boolean) actual).booleanValue());
  }

  /**
   * Asserts that actual == null
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   */
  public void assertNull(String assertID, Object actual) {
    framework.assertNull(this, assertID, actual);
  }

  /**
   * Asserts that actual != null
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   */
  public void assertNotNull(String assertID, Object actual) {
    framework.assertNotNull(this, assertID, actual);
  }

  /**
   * Asserts that actual and expected are the same object
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   */
  public void assertSame(String assertID, Object expected, Object actual) {
    framework.assertSame(this, assertID, expected, actual);
  }

  /**
   * Asserts that obj is an instance of cls
   *
   * @param assertID
   *            identifier of assertion
   * @param obj
   *            object
   * @param cls
   *            class, may not be null.
   */
  public void assertInstanceOf(String assertID, Class cls, Object obj) {
    framework.assertInstanceOf(this, assertID, obj, cls);
  }

  /**
   * Asserts that the length of the collection is the expected size.
   *
   * @param assertID
   *            identifier of assertion
   * @param expectedSize
   *            expected size
   * @param collection
   *            collection
   */
  public void assertSize(
      String assertID,
      int expectedSize,
      NodeList collection) {
    framework.assertSize(this, assertID, expectedSize, collection);
  }

  /**
   * Asserts that the length of the collection is the expected size.
   *
   * @param assertID
   *            identifier of assertion
   * @param expectedSize
   *            expected size
   * @param collection
   *            collection
   */
  public void assertSize(
      String assertID,
      int expectedSize,
      NamedNodeMap collection) {
    framework.assertSize(this, assertID, expectedSize, collection);
  }

  /**
   * Asserts that the length of the collection is the expected size.
   *
   * @param assertID
   *            identifier of assertion
   * @param expectedSize
   *            expected size
   * @param collection
   *            collection
   */
  public void assertSize(
      String assertID,
      int expectedSize,
      Collection collection) {
    framework.assertSize(this, assertID, expectedSize, collection);
  }

  /**
   * Asserts that expected.equalsIgnoreCase(actual) is true
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   * @param expected
   *            Expected value, may not be null.
   */
  public void assertEqualsIgnoreCase(
      String assertID,
      String expected,
      String actual) {
    framework.assertEqualsIgnoreCase(this, assertID, expected, actual);
  }

  /**
   * Asserts that each entry in actual is matched with an entry in expected
   * that only differs by case. Order is not significant.
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   * @param expected
   *            Expected value, may not be null.
   */
  public void assertEqualsIgnoreCase(
      String assertID,
      Collection expected,
      Collection actual) {
    framework.assertEqualsIgnoreCase(this, assertID, expected, actual);
  }

  /**
   * Asserts that each entry in actual is matched with an entry in expected
   * that only differs by case. Order is significant.
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   * @param expected
   *            Expected value, may not be null.
   */
  public void assertEqualsIgnoreCase(
      String assertID,
      List expected,
      List actual) {
    framework.assertEqualsIgnoreCase(this, assertID, expected, actual);
  }

  /**
   * Asserts that expected.equalsIgnoreCase(actual) is true
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   * @param expected
   *            Expected value, may not be null.
   */
  public void assertEqualsAutoCase(
      String context,
      String assertID,
      String expected,
      String actual) {
    String contentType = getContentType();
    //
    //   if the content type is HTML (not XHTML)
    //
    if ("text/html".equals(contentType)) {
      //
      //  if the context is attribute, then use case-insentive comparison
      //
      if ("attribute".equals(context)) {
        framework.assertEqualsIgnoreCase(this, assertID, expected, actual);
      }
      else {
        //
        //  otherwise should be compared against uppercased expectation
        framework.assertEquals(this, assertID, expected.toUpperCase(), actual);
      }
    }
    else {
      framework.assertEquals(this, assertID, expected, actual);
    }
  }

  /**
   * Creates an equivalent list where every member has
   *     been uppercased
   *
   */
  private List toUpperCase(Collection expected) {
    List upperd = new ArrayList(expected.size());
    Iterator iter = expected.iterator();
    while (iter.hasNext()) {
      upperd.add(iter.next().toString().toUpperCase());
    }
    return upperd;
  }

  /**
   * Asserts that each entry in actual is matched with an entry in expected
   * that only differs by case. Order is not significant.
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   * @param expected
   *            Expected value, may not be null.
   */
  public void assertEqualAutoCase(
      String context,
      String assertID,
      Collection expected,
      Collection actual) {
    String contentType = getContentType();
    if ("text/html".equals(contentType)) {
      if ("attribute".equals(context)) {
        assertEqualsIgnoreCase(assertID, expected, actual);
      }
      else {
        framework.assertEquals(this, assertID, toUpperCase(expected), actual);
      }

    }
    else {
      framework.assertEquals(this, assertID, expected, actual);
    }
  }

  /**
   * Asserts that each entry in actual is matched with an entry in expected
   * that only differs by case. Order is significant.
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   * @param expected
   *            Expected value, may not be null.
   */
  public void assertEqualsAutoCase(
      String context,
      String assertID,
      List expected,
      List actual) {
    String contentType = getContentType();
    if ("text/html".equals(contentType)) {
      if ("attribute".equals(context)) {
        assertEqualsIgnoreCase(assertID, expected, actual);
      }
      else {
        framework.assertEquals(this, assertID, toUpperCase(expected), actual);
      }

    }
    else {
      framework.assertEquals(this, assertID, expected, actual);
    }
  }

  /**
   * Asserts that expected.equals(actual) is true
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   * @param expected
   *            Expected value, may not be null.
   */
  public void assertEquals(String assertID, String expected, String actual) {
    framework.assertEquals(this, assertID, expected, actual);
  }

  /**
   * Asserts that values of expected and actual are equal.
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   * @param expected
   *            Expected value, may not be null.
   */
  public void assertEquals(String assertID, int expected, int actual) {
    framework.assertEquals(this, assertID, expected, actual);
  }

  /**
   * Asserts that values of expected and actual are equal.
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   * @param expected
   *            Expected value, may not be null.
   */
  public void assertEquals(String assertID, double expected, double actual) {
    framework.assertEquals(this, assertID, expected, actual);
  }

  /**
   * Asserts that values of expected and actual are equal.
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   * @param expected
   *            Expected value, may not be null.
   */
  public void assertEquals(
      String assertID,
      boolean expected,
      boolean actual) {
    framework.assertEquals(this, assertID, expected, actual);
  }

  /**
   * Asserts that each entry in actual exactly matches with an entry in
   * expected. Order is not significant.
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   * @param expected
   *            Expected value, may not be null.
   */
  public void assertEquals(
      String assertID,
      Collection expected,
      NodeList actual) {
    Collection actualList = new ArrayList();
    int actualLen = actual.getLength();
    for (int i = 0; i < actualLen; i++) {
      actualList.add(actual.item(i));
    }
    framework.assertEquals(this, assertID, expected, actualList);
  }

  /**
   * Asserts that each entry in actual exactly matches with an entry in
   * expected. Order is not significant.
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   * @param expected
   *            Expected value, may not be null.
   */
  public void assertEquals(
      String assertID,
      Collection expected,
      Collection actual) {
    framework.assertEquals(this, assertID, expected, actual);
  }

  /**
   * Asserts that expected.equalsIgnoreCase(actual) is false
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   * @param expected
   *            Expected value, may not be null.
   */
  public void assertNotEqualsIgnoreCase(
      String assertID,
      String expected,
      String actual) {
    framework.assertNotEqualsIgnoreCase(this, assertID, expected, actual);
  }

  /**
   * Asserts that expected.equalsIgnoreCase(actual) is false
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   * @param expected
   *            Expected value, may not be null.
   */
  public void assertNotEqualsAutoCase(
      String context,
      String assertID,
      String expected,
      String actual) {
    String contentType = getContentType();
    if ("text/html".equals(contentType)) {
      if ("attribute".equals(context)) {
        framework.assertNotEqualsIgnoreCase(this, assertID, expected, actual);
      }
      else {
        framework.assertNotEquals(this, assertID, expected.toUpperCase(),
                                  actual);
      }
    }
    framework.assertNotEquals(this, assertID, expected, actual);
  }

  /**
   * Asserts that values of expected and actual are not equal.
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   * @param expected
   *            Expected value, may not be null.
   */
  public void assertNotEquals(
      String assertID,
      String expected,
      String actual) {
    framework.assertNotEquals(this, assertID, expected, actual);
  }

  /**
   * Asserts that values of expected and actual are not equal.
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   * @param expected
   *            Expected value, may not be null.
   */
  public void assertNotEquals(String assertID, int expected, int actual) {
    framework.assertNotEquals(this, assertID, expected, actual);
  }

  /**
   * Asserts that values of expected and actual are not equal.
   *
   * @param assertID
   *            identifier of assertion
   * @param actual
   *            actual value
   * @param expected
   *            Expected value, may not be null.
   */
  public void assertNotEquals(
      String assertID,
      double expected,
      double actual) {
    framework.assertNotEquals(this, assertID, expected, actual);
  }

  /**
   * Asserts aspects of a URI
   *
   * @param assertID
   *            identifier of assertion
   * @param scheme
   *            Expected scheme, for example, "file". If null, scheme is
   *            ignored.
   * @param path
   *            Expected path, for example, "/DOM/Test". If null, path is
   *            ignored.
   * @param host
   *            Expected host, for example, "www.w3.org". If null, host is
   *            ignored.
   * @param file
   *            Expected file, for example, "staff.xml". If null, file is
   *            ignored.
   * @param name
   *            Expected name, for example, "staff". If null, name is
   *            ignored.
   * @param name
   *            Expected name, for example, "staff". If null, name is
   *            ignored.
   * @param isAbsolute
   *            if Boolean.TRUE, URI must be absolute. Null indicates no
   *            assertion.
   * @param actual
   *            URI to be tested.
   */
  public void assertURIEquals(
      String assertID,
      String scheme,
      String path,
      String host,
      String file,
      String name,
      String query,
      String fragment,
      Boolean isAbsolute,
      String actual) {
    //
    //  URI must be non-null
    assertNotNull(assertID, actual);

    String uri = actual;

    int lastPound = actual.lastIndexOf("#");
    String actualFragment = "";
    if (lastPound != -1) {
      //
      //   substring before pound
      //
      uri = actual.substring(0, lastPound);
      actualFragment = actual.substring(lastPound + 1);
    }
    if (fragment != null) {
      assertEquals(assertID, fragment, actualFragment);

    }
    int lastQuestion = uri.lastIndexOf("?");
    String actualQuery = "";
    if (lastQuestion != -1) {
      //
      //   substring before pound
      //
      uri = actual.substring(0, lastQuestion);
      actualQuery = actual.substring(lastQuestion + 1);
    }
    if (query != null) {
      assertEquals(assertID, query, actualQuery);

    }
    int firstColon = uri.indexOf(":");
    int firstSlash = uri.indexOf("/");
    String actualPath = uri;
    String actualScheme = "";
    if (firstColon != -1 && firstColon < firstSlash) {
      actualScheme = uri.substring(0, firstColon);
      actualPath = uri.substring(firstColon + 1);
    }

    if (scheme != null) {
      assertEquals(assertID, scheme, actualScheme);
    }

    if (path != null) {
      assertEquals(assertID, path, actualPath);
    }

    if (host != null) {
      String actualHost = "";
      if (actualPath.startsWith("//")) {
        int termSlash = actualPath.indexOf("/", 2);
        actualHost = actualPath.substring(0, termSlash);
      }
      assertEquals(assertID, host, actualHost);
    }

    String actualFile = actualPath;
    if (file != null || name != null) {
      int finalSlash = actualPath.lastIndexOf("/");
      if (finalSlash != -1) {
        actualFile = actualPath.substring(finalSlash + 1);
      }
      if (file != null) {
        assertEquals(assertID, file, actualFile);
      }
    }

    if (name != null) {
      String actualName = actualFile;
      int finalPeriod = actualFile.lastIndexOf(".");
      if (finalPeriod != -1) {
        actualName = actualFile.substring(0, finalPeriod);
      }
      assertEquals(assertID, name, actualName);
    }

    if (isAbsolute != null) {
      //
      //   Jar URL's will have any actual path like file:/c:/somedrive...
      assertEquals(
          assertID,
          isAbsolute.booleanValue(),
          actualPath.startsWith("/") || actualPath.startsWith("file:/"));
    }
  }

  /**
   * Compares the identity of actual and expected.
   *
   * @param expected
   *            expected
   * @param actual
   *            actual
   * @return true if actual and expected are the same object.
   */
  public boolean same(Object expected, Object actual) {
    return framework.same(expected, actual);
  }

  /**
   * Compares the value of actual and expected ignoring case.
   *
   * @param expected
   *            expected
   * @param actual
   *            actual
   * @return true if actual and expected are equal ignoring case.
   */
  public boolean equalsIgnoreCase(String expected, String actual) {
    return framework.equalsIgnoreCase(expected, actual);
  }

  /**
   * Compares the values in actual and expected ignoring case and order.
   *
   * @param expected
   *            expected
   * @param actual
   *            actual
   * @return true if actual and expected are equal ignoring case.
   */
  public boolean equalsIgnoreCase(Collection expected, Collection actual) {
    return framework.equalsIgnoreCase(expected, actual);
  }

  /**
   * Compares the values in actual and expected ignoring case.
   *
   * @param expected
   *            expected
   * @param actual
   *            actual
   * @return true if actual and expected are equal ignoring case.
   */
  public boolean equalsIgnoreCase(List expected, List actual) {
    return framework.equalsIgnoreCase(expected, actual);
  }

  /**
   * Compares the value of actual and expected ignoring case.
   *
   * @param expected
   *            expected
   * @param actual
   *            actual
   * @return true if actual and expected are equal ignoring case.
   */
  public boolean equalsAutoCase(String context, String expected, String actual) {
    if ("text/html".equals(getContentType())) {
      if ("attribute".equals(context)) {
        return framework.equalsIgnoreCase(expected, actual);
      }
      else {
        return framework.equals(expected.toUpperCase(), actual);
      }
    }
    return framework.equals(expected, actual);
  }

  /**
   * Compares the values in actual and expected ignoring case and order.
   *
   * @param expected
   *            expected
   * @param actual
   *            actual
   * @return true if actual and expected are equal ignoring case.
   */
  public boolean equalsAutoCase(String context, Collection expected,
                                Collection actual) {
    if ("text/html".equals(getContentType())) {
      if ("attribute".equals(context)) {
        return framework.equalsIgnoreCase(expected, actual);
      }
      else {
        return framework.equals(toUpperCase(expected), actual);
      }
    }
    return framework.equals(expected, actual);
  }

  /**
   * Compares the values in actual and expected ignoring case.
   *
   * @param expected
   *            expected
   * @param actual
   *            actual
   * @return true if actual and expected are equal ignoring case.
   */
  public boolean equalsAutoCase(String context, List expected, List actual) {
    if ("text/html".equals(getContentType())) {
      if ("attribute".equals(context)) {
        return framework.equalsIgnoreCase(expected, actual);
      }
      else {
        return framework.equals(toUpperCase(expected), actual);
      }
    }
    return framework.equals(expected, actual);
  }

  /**
   * Compares the values of actual and expected.
   *
   * @param expected
   *            expected
   * @param actual
   *            actual
   * @return true if actual and expected are equal.
   */
  public boolean equals(String expected, String actual) {
    return framework.equals(expected, actual);
  }

  /**
   * Compares the values of actual and expected.
   *
   * @param expected
   *            expected
   * @param actual
   *            actual
   * @return true if actual and expected are equal.
   */
  public boolean equals(int expected, int actual) {
    return framework.equals(expected, actual);
  }

  /**
   * Compares the values of actual and expected.
   *
   * @param expected
   *            expected
   * @param actual
   *            actual
   * @return true if actual and expected are equal.
   */
  public boolean equals(double expected, double actual) {
    return framework.equals(expected, actual);
  }

  /**
   * Compares the values in actual and expected ignoring order.
   *
   * @param expected
   *            expected
   * @param actual
   *            actual
   * @return true if actual and expected are equal.
   */
  public boolean equals(Collection expected, Collection actual) {
    return framework.equals(expected, actual);
  }

  /**
   * Compares the values in actual and expected.
   *
   * @param expected
   *            expected
   * @param actual
   *            actual
   * @return true if actual and expected are equal.
   */
  public boolean equals(List expected, List actual) {
    return framework.equals(expected, actual);
  }

  /**
   * Gets the size of the collection
   *
   * @param collection
   *            collection, may not be null.
   * @return size of collection
   */
  public int size(Collection collection) {
    return framework.size(collection);
  }

  /**
   * Gets the size of the collection
   *
   * @param collection
   *            collection, may not be null.
   * @return size of collection
   */
  public int size(NamedNodeMap collection) {
    return framework.size(collection);
  }

  /**
   * Gets the size of the collection
   *
   * @param collection
   *            collection, may not be null.
   * @return size of collection
   */
  public int size(NodeList collection) {
    return framework.size(collection);
  }

}