/*
* 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);
}
}
|
