summaryrefslogtreecommitdiffstats
path: root/dom/src/test/java/org/w3c/domts/JUnitTestCaseAdapter.java
diff options
context:
space:
mode:
Diffstat (limited to 'dom/src/test/java/org/w3c/domts/JUnitTestCaseAdapter.java')
-rw-r--r--dom/src/test/java/org/w3c/domts/JUnitTestCaseAdapter.java368
1 files changed, 368 insertions, 0 deletions
diff --git a/dom/src/test/java/org/w3c/domts/JUnitTestCaseAdapter.java b/dom/src/test/java/org/w3c/domts/JUnitTestCaseAdapter.java
new file mode 100644
index 0000000..6180147
--- /dev/null
+++ b/dom/src/test/java/org/w3c/domts/JUnitTestCaseAdapter.java
@@ -0,0 +1,368 @@
+/*
+ * 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.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
+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;
+
+ public JUnitTestCaseAdapter(DOMTestCase test) {
+ super(test.getTargetURI());
+ test.setFramework(this);
+ this.test = test;
+ }
+
+ protected void runTest() throws Throwable {
+ 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();
+ }
+
+
+} \ No newline at end of file
generated by cgit v1.1 at 2024-06-10 12:04:52 +0000