/*
* Copyright (c) 2001-2003 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.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Logger;
import javax.xml.parsers.DocumentBuilder;
import junit.framework.TestCase;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
public class JUnitTestCaseAdapter extends TestCase implements DOMTestFramework {
private DOMTestCase test;
private static DOMTestDocumentBuilderFactory defaultFactory = null;
public JUnitTestCaseAdapter(DOMTestCase test) {
super(test.getTargetURI());
test.setFramework(this);
this.test = test;
}
//BEGIN android-added
public JUnitTestCaseAdapter() {
}
private String errorMessage = null;
private boolean failed = false;
@Override
public void setName(String name) {
super.setName(name);
if (test == null) {
try {
URI uri = new URI(name);
String path = uri.getPath();
path = path.replaceAll("/", ".");
Class<?> clazz = null;
int pos = path.indexOf('.');
while (pos != -1) {
try {
clazz = Class.forName("org.w3c.domts." + path);
break;
} catch (ClassNotFoundException e) {
// do nothing
}
path = path.substring(pos + 1);
}
if (clazz == null) {
errorMessage = "class not found for test: " + name;
failed = true;
return;
}
if (defaultFactory == null) {
defaultFactory = new JAXPDOMTestDocumentBuilderFactory(null,
JAXPDOMTestDocumentBuilderFactory.getConfiguration1());
}
Constructor<?> constructor = clazz.getConstructor(new Class<?>[] {
DOMTestDocumentBuilderFactory.class
});
test = (DOMTestCase)constructor.newInstance(new Object[] {
defaultFactory
});
test.setFramework(this);
} catch (URISyntaxException e) {
failed = true;
errorMessage = e.getMessage();
if (errorMessage == null) {
errorMessage = "" + e.toString();
}
} catch (IllegalAccessException e) {
failed = true;
errorMessage = e.getMessage();
if (errorMessage == null) {
errorMessage = "" + e.toString();
}
} catch (InstantiationException e) {
failed = true;
errorMessage = e.getMessage();
if (errorMessage == null) {
errorMessage = "" + e.toString();
}
} catch (DOMTestIncompatibleException e) {
failed = true;
errorMessage = e.getMessage();
if (errorMessage == null) {
errorMessage = "" + e.toString();
}
} catch (SecurityException e) {
failed = true;
errorMessage = e.getMessage();
if (errorMessage == null) {
errorMessage = "" + e.toString();
}
} catch (NoSuchMethodException e) {
failed = true;
errorMessage = e.getMessage();
if (errorMessage == null) {
errorMessage = "" + e.toString();
}
} catch (IllegalArgumentException e) {
failed = true;
errorMessage = e.getMessage();
if (errorMessage == null) {
errorMessage = "" + e.toString();
}
} catch (InvocationTargetException e) {
failed = true;
Throwable t = e.getCause();
if (t != null) {
errorMessage = t.getMessage();
if (errorMessage == null) {
errorMessage = "" + t.toString();
}
} else {
errorMessage = e.getMessage();
if (errorMessage == null) {
errorMessage = "" + e.toString();
}
}
}
}
}
//END android-added
protected void runTest() throws Throwable {
//BEGIN android-added
if (failed) {
if (errorMessage != null) {
fail(errorMessage);
} else {
fail("init failed");
}
}
//END android-added
test.runTest();
int mutationCount = test.getMutationCount();
if (mutationCount != 0) {
fail("Document loaded with willBeModified='false' was modified in course of test.");
}
}
public boolean hasFeature(DocumentBuilder docBuilder,
String feature,
String version) {
return docBuilder.getDOMImplementation().hasFeature(feature,version);
}
public void wait(int millisecond) {
}
public void fail(DOMTestCase test, String assertID) {
fail(assertID);
}
public void assertTrue(DOMTestCase test, String assertID, boolean actual) {
assertTrue(assertID,actual);
}
public void assertFalse(DOMTestCase test, String assertID, boolean actual) {
if(actual) {
assertEquals(assertID,String.valueOf(false), String.valueOf(actual));
}
}
public void assertNull(DOMTestCase test, String assertID, Object actual) {
assertNull(assertID,actual);
}
public void assertNotNull(DOMTestCase test, String assertID, Object actual) {
assertNotNull(assertID,actual);
}
public void assertSame(DOMTestCase test, String assertID, Object expected, Object actual) {
boolean same = (expected == actual);
//
// if the not the same but both are not null
// might still really be the same
//
if(!same) {
if(expected == null || actual == null ||
!(expected instanceof Node) || !(actual instanceof Node)) {
assertEquals(assertID,expected,actual);
}
else {
//
// could do something with isSame
//
assertEquals(assertID,expected,actual);
}
}
}
public void assertInstanceOf(DOMTestCase test, String assertID, Object obj, Class cls) {
assertTrue(assertID,cls.isInstance(obj));
}
public void assertSize(DOMTestCase test, String assertID, int expectedSize, NodeList collection) {
assertEquals(assertID,expectedSize, collection.getLength());
}
public void assertSize(DOMTestCase test, String assertID, int expectedSize, NamedNodeMap collection) {
assertEquals(assertID, expectedSize, collection.getLength());
}
public void assertSize(DOMTestCase test, String assertID, int expectedSize, Collection collection) {
assertEquals(assertID, expectedSize, collection.size());
}
public void assertEqualsIgnoreCase(DOMTestCase test, String assertID, String expected, String actual) {
if (!expected.equalsIgnoreCase(actual)) {
assertEquals(assertID,expected, actual);
}
}
public void assertEqualsIgnoreCase(DOMTestCase test, String assertID, Collection expected, Collection actual) {
int size = expected.size();
assertNotNull(assertID,expected);
assertNotNull(assertID,actual);
assertEquals(assertID,size, actual.size());
boolean equals = (expected != null && actual != null && size == actual.size());
if(equals) {
List expectedArray = new ArrayList(expected);
String expectedString;
String actualString;
Iterator actualIter = actual.iterator();
Iterator expectedIter;
while(actualIter.hasNext() && equals) {
actualString = (String) actualIter.next();
expectedIter = expectedArray.iterator();
equals = false;
while(expectedIter.hasNext() && !equals) {
expectedString = (String) expectedIter.next();
if(actualString.equalsIgnoreCase(expectedString)) {
equals = true;
expectedArray.remove(expectedString);
}
}
}
}
assertTrue(assertID,equals);
}
public void assertEqualsIgnoreCase(DOMTestCase test, String assertID, List expected, List actual) {
int size = expected.size();
assertNotNull(assertID,expected);
assertNotNull(assertID,actual);
assertEquals(assertID,size, actual.size());
boolean equals = (expected != null && actual != null && size == actual.size());
if(equals) {
String expectedString;
String actualString;
for(int i = 0; i < size; i++) {
expectedString = (String) expected.get(i);
actualString = (String) actual.get(i);
if(!expectedString.equalsIgnoreCase(actualString)) {
assertEquals(assertID,expectedString,actualString);
break;
}
}
}
}
public void assertEquals(DOMTestCase test, String assertID, String expected, String actual) {
assertEquals(assertID,expected,actual);
}
public void assertEquals(DOMTestCase test, String assertID, int expected, int actual) {
assertEquals(assertID,expected,actual);
}
public void assertEquals(DOMTestCase test, String assertID, boolean expected, boolean actual) {
assertEquals(assertID,expected,actual);
}
public void assertEquals(DOMTestCase test, String assertID, double expected, double actual) {
assertEquals(assertID, expected, actual, 0.0);
}
public void assertEquals(DOMTestCase test, String assertID, Collection expected, Collection actual) {
int size = expected.size();
assertNotNull(assertID,expected);
assertNotNull(assertID,actual);
assertEquals(assertID,size, actual.size());
boolean equals = (expected != null && actual != null && size == actual.size());
if(equals) {
List expectedArray = new ArrayList(expected);
Object expectedObj;
Object actualObj;
Iterator actualIter = actual.iterator();
Iterator expectedIter;
while(actualIter.hasNext() && equals) {
actualObj = actualIter.next();
expectedIter = expectedArray.iterator();
equals = false;
while(expectedIter.hasNext() && !equals) {
expectedObj = expectedIter.next();
if(expectedObj == actualObj || expectedObj.equals(actualObj)) {
equals = true;
expectedArray.remove(expectedObj);
}
}
}
}
assertTrue(assertID,equals);
}
public void assertNotEqualsIgnoreCase(DOMTestCase test, String assertID, String expected, String actual) {
if(expected.equalsIgnoreCase(actual)) {
assertTrue(assertID, !expected.equalsIgnoreCase(actual));
}
}
public void assertNotEquals(DOMTestCase test, String assertID, String expected, String actual) {
assertTrue(assertID, !expected.equals(actual));
}
public void assertNotEquals(DOMTestCase test, String assertID, int expected, int actual) {
assertTrue(assertID,expected !=actual);
}
public void assertNotEquals(DOMTestCase test, String assertID, boolean expected, boolean actual) {
assertTrue(assertID,expected !=actual);
}
public void assertNotEquals(DOMTestCase test, String assertID, double expected, double actual) {
if(expected == actual) {
assertTrue(assertID,expected != actual);
}
}
public boolean same(Object expected, Object actual) {
boolean equals = (expected == actual);
if(!equals && expected != null && expected instanceof Node &&
actual != null && actual instanceof Node) {
//
// can use Node.isSame eventually
}
return equals;
}
public boolean equalsIgnoreCase(String expected, String actual) {
return expected.equalsIgnoreCase(actual);
}
public boolean equalsIgnoreCase(Collection expected, Collection actual) {
int size = expected.size();
boolean equals = (expected != null && actual != null && size == actual.size());
if(equals) {
List expectedArray = new ArrayList(expected);
String expectedString;
String actualString;
Iterator actualIter = actual.iterator();
Iterator expectedIter;
while(actualIter.hasNext() && equals) {
actualString = (String) actualIter.next();
expectedIter = expectedArray.iterator();
equals = false;
while(expectedIter.hasNext() && !equals) {
expectedString = (String) expectedIter.next();
if(actualString.equalsIgnoreCase(expectedString)) {
equals = true;
expectedArray.remove(expectedString);
}
}
}
}
return equals;
}
public boolean equalsIgnoreCase(List expected, List actual) {
int size = expected.size();
boolean equals = (expected != null && actual != null && size == actual.size());
if(equals) {
String expectedString;
String actualString;
for(int i = 0; i < size; i++) {
expectedString = (String) expected.get(i);
actualString = (String) actual.get(i);
if(!expectedString.equalsIgnoreCase(actualString)) {
equals = false;
break;
}
}
}
return equals;
}
public boolean equals(String expected, String actual) {
return expected.equals(actual);
}
public boolean equals(int expected, int actual) {
return expected == actual;
}
public boolean equals(boolean expected, boolean actual) {
return expected == actual;
}
public boolean equals(double expected, double actual) {
return expected == actual;
}
public boolean equals(Collection expected, Collection actual) {
int size = expected.size();
boolean equals = (expected != null && actual != null && size == actual.size());
if(equals) {
List expectedArray = new ArrayList(expected);
Object expectedObj;
Object actualObj;
Iterator actualIter = actual.iterator();
Iterator expectedIter;
while(actualIter.hasNext() && equals) {
actualObj = actualIter.next();
expectedIter = expectedArray.iterator();
equals = false;
while(expectedIter.hasNext() && !equals) {
expectedObj = expectedIter.next();
if(expectedObj != actualObj && expectedObj.equals(actualObj)) {
equals = true;
expectedArray.remove(expectedObj);
}
}
}
}
return equals;
}
public boolean equals(List expected, List actual) {
int size = expected.size();
boolean equals = (expected != null && actual != null && size == actual.size());
if(equals) {
Object expectedObj;
Object actualObj;
for(int i = 0; i < size; i++) {
expectedObj = expected.get(i);
actualObj = actual.get(i);
if(!expectedObj.equals(actualObj)) {
equals = false;
break;
}
}
}
return equals;
}
public int size(Collection collection) {
return collection.size();
}
public int size(NamedNodeMap collection) {
return collection.getLength();
}
public int size(NodeList collection) {
return collection.getLength();
}
} |
