org.xmlcml.testutil.TestUtils Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of euclid Show documentation
Show all versions of euclid Show documentation
A Java library for 2D and 3D geometric calculations
/**
* Copyright 2011 Peter Murray-Rust
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.xmlcml.testutil;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.StringWriter;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import junit.framework.AssertionFailedError;
import junit.framework.ComparisonFailure;
import nu.xom.Attribute;
import nu.xom.Builder;
import nu.xom.Comment;
import nu.xom.Element;
import nu.xom.Elements;
import nu.xom.Node;
import nu.xom.ProcessingInstruction;
import nu.xom.Text;
import nu.xom.tests.XOMTestCase;
import org.apache.log4j.Logger;
import org.joda.time.DateTime;
import org.junit.Assert;
import org.xmlcml.euclid.EC;
import org.xmlcml.euclid.EuclidRuntimeException;
import org.xmlcml.euclid.IntArray;
import org.xmlcml.euclid.IntMatrix;
import org.xmlcml.euclid.IntSet;
import org.xmlcml.euclid.JodaDate;
import org.xmlcml.euclid.Line3;
import org.xmlcml.euclid.Plane3;
import org.xmlcml.euclid.Point3;
import org.xmlcml.euclid.Point3Vector;
import org.xmlcml.euclid.Real;
import org.xmlcml.euclid.Real2;
import org.xmlcml.euclid.Real2Vector;
import org.xmlcml.euclid.Real3Range;
import org.xmlcml.euclid.RealArray;
import org.xmlcml.euclid.RealMatrix;
import org.xmlcml.euclid.RealRange;
import org.xmlcml.euclid.RealSquareMatrix;
import org.xmlcml.euclid.Transform2;
import org.xmlcml.euclid.Transform3;
import org.xmlcml.euclid.Util;
import org.xmlcml.euclid.Vector2;
import org.xmlcml.euclid.Vector3;
import org.xmlcml.stml.STMLConstants;
import org.xmlcml.stml.STMLElement;
import org.xmlcml.xml.XMLUtil;
/**
*
*
* Utility library of common methods for unit tests
*
*
* @author Peter Murray-Rust
* @version 5.0
*
*/
public final class TestUtils implements STMLConstants {
/** logger */
private final static Logger logger = Logger.getLogger(TestUtils.class);
public static final String OUTPUT_DIR_NAME = "target/test-outputs";
/**
* tests 2 XML objects for equality using canonical XML. uses
* XOMTestCase.assertEquals. This treats different prefixes as different and
* compares floats literally.
*
* @param message
* @param refNode
* first node
* @param testNode
* second node
*/
public static void assertEqualsCanonically(String message, Node refNode,
Node testNode) {
try {
XOMTestCase.assertEquals(message, refNode, testNode);
} catch (ComparisonFailure e) {
reportXMLDiff(message, e.getMessage(), refNode, testNode);
} catch (AssertionFailedError e) {
reportXMLDiff(message, e.getMessage(), refNode, testNode);
}
}
/**
* compares two XML nodes and checks float near-equivalence (can also be
* used for documents without floats) usesTestUtils.assertEqualsCanonically
* and only uses PMR code if fails
*
* @param message
* @param refNode
* @param testNode
* @param eps
*/
public static void assertEqualsIncludingFloat(String message, Node refNode,
Node testNode, boolean stripWhite, double eps) {
if (stripWhite && refNode instanceof Element
&& testNode instanceof Element) {
refNode = stripWhite((Element) refNode);
testNode = stripWhite((Element) testNode);
}
try {
assertEqualsIncludingFloat(message, refNode, testNode, eps);
} catch (AssertionError e) {
logger.warn(e);
reportXMLDiffInFull(message, e.getMessage(), refNode, testNode);
}
}
public static void assertEqualsIncludingFloat(String message,
String expectedS, Node testNode, boolean stripWhite, double eps) {
assertEqualsIncludingFloat(message, TestUtils
.parseValidString(expectedS), testNode, stripWhite, eps);
}
private static void assertEqualsIncludingFloat(String message,
Node refNode, Node testNode, double eps) {
try {
Assert.assertEquals(message + ": classes", testNode.getClass(),
refNode.getClass());
if (refNode instanceof Text) {
testStringDoubleEquality(message + " on node: "
+ path(testNode), refNode.getValue().trim(), testNode
.getValue().trim(), eps);
} else if (refNode instanceof Comment) {
Assert.assertEquals(message + " comment", refNode.getValue(),
testNode.getValue());
} else if (refNode instanceof ProcessingInstruction) {
Assert.assertEquals(message + " pi",
(ProcessingInstruction) refNode,
(ProcessingInstruction) testNode);
} else if (refNode instanceof Element) {
int refNodeChildCount = refNode.getChildCount();
int testNodeChildCount = testNode.getChildCount();
String path = path(testNode);
// FIXME? fails to resolve in tests
// Assert.assertEquals("number of children of " + path,
// refNodeChildCount, testNodeChildCount);
if (refNodeChildCount != testNodeChildCount) {
Assert.fail("number of children of " + path + " "+
refNodeChildCount + " != " + testNodeChildCount);
}
for (int i = 0; i < refNodeChildCount; i++) {
assertEqualsIncludingFloat(message, refNode.getChild(i),
testNode.getChild(i), eps);
}
Element refElem = (Element) refNode;
Element testElem = (Element) testNode;
Assert.assertEquals(message + " name", refElem.getLocalName(),
testElem.getLocalName());
Assert.assertEquals(message + " namespace", refElem
.getNamespaceURI(), testElem.getNamespaceURI());
Assert.assertEquals(message + " attributes on "
+ refElem.getClass(), refElem.getAttributeCount(),
testElem.getAttributeCount());
for (int i = 0; i < refElem.getAttributeCount(); i++) {
Attribute refAtt = refElem.getAttribute(i);
String attName = refAtt.getLocalName();
String attNamespace = refAtt.getNamespaceURI();
Attribute testAtt = testElem.getAttribute(attName,
attNamespace);
if (testAtt == null) {
// XMLUtil.debug((Element)refNode, "XXXXXXXXXXX");
// XMLUtil.debug((Element)testNode, "TEST");
Assert.fail(message + " attribute on ref not on test: "
+ attName);
}
testStringDoubleEquality(message + " attribute "
+ path(testAtt) + " values differ:", refAtt
.getValue(), testAtt.getValue(), eps);
}
} else {
Assert.fail(message + "cannot deal with XMLNode: "
+ refNode.getClass());
}
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private static String path(Node testNode) {
List fullpath = path(testNode, new ArrayList());
Collections.reverse(fullpath);
StringBuilder sb = new StringBuilder();
for (String p : fullpath) {
sb.append(p);
}
return sb.toString();
}
private static List path(Node testNode, List path) {
if (testNode instanceof Element) {
Element e = (Element) testNode;
StringBuilder frag = new StringBuilder("/");
if (!"".equals(e.getNamespacePrefix())) {
frag.append(e.getNamespacePrefix()).append(":");
}
path.add(frag.append(e.getLocalName()).append("[").append(
siblingOrdinal(e)).append("]").toString());
} else if (testNode instanceof Attribute) {
Attribute a = (Attribute) testNode;
path.add(new StringBuilder("@").append(a.getNamespacePrefix())
.append(":").append(a.getLocalName()).toString());
} else if (testNode instanceof Text) {
path.add("/text()");
}
return (testNode.getParent() != null) ? path(testNode.getParent(), path)
: path;
}
private static int siblingOrdinal(Element e) {
Element parent = (Element) e.getParent();
if (parent == null) {
return 0;
} else {
Elements els = parent.getChildElements(e.getLocalName(), e
.getNamespaceURI());
for (int i = 0; i < els.size(); i++) {
if (els.get(i).equals(e)) {
return i;
}
}
throw new RuntimeException(
"Element was not a child of its parent. Most perplexing!");
}
}
private static void testStringDoubleEquality(String message,
String refValue, String testValue, double eps) {
testValue = testValue.trim();
refValue = refValue.trim();
// maybe
if (testValue.endsWith(" ") || refValue.endsWith(" ")) {
throw new RuntimeException("trim error");
}
if (!testValue.equals(refValue)) {
boolean fail = true;
try {
compareAsFloats(message, refValue, testValue, eps);
fail = false;
} catch (Exception e) {
}
if (fail) {
try {
compareAsFloatArrays(message, refValue, testValue, eps);
fail = false;
} catch (Exception e) {
}
}
if (fail) {
try {
compareAsDates(message, refValue, testValue, eps);
fail = false;
} catch (Exception e) {
}
}
if (fail) {
Assert.fail("Cannot equate: "+refValue+" != "+testValue);
}
} else {
Assert.assertEquals(message, refValue, testValue);
}
}
private static void compareAsFloats(String message, String refValue,
String testValue, double eps) {
double testVal = Double.NaN;
double refVal = Double.NaN;
Error ee = null;
try {
try {
testVal = new Double(testValue).doubleValue();
refVal = new Double(refValue).doubleValue();
Assert.assertEquals(message + " doubles ", refVal, testVal,
eps);
} catch (NumberFormatException e) {
Assert.assertEquals(message + " String ", refValue, testValue);
}
} catch (ComparisonFailure e) {
ee = e;
} catch (AssertionError e) {
ee = e;
}
if (ee != null) {
throw new RuntimeException("["+testValue+"] != ["+refValue+"]" ,ee);
}
}
/** I am still haveing problems with dates
* if these ARE both dates assume they are equal (because of time zones
* sorry)
* @param message
* @param refValue
* @param testValue
* @param eps
*/
private static void compareAsDates(String message, String refValue,
String testValue, double eps) {
DateTime testVal = null;
DateTime refVal = null;
try {
testVal = JodaDate.parseDate(testValue);
refVal = JodaDate.parseDate(refValue);
// Assert.assertEquals(message + " date ", refVal, testVal);
} catch (Exception e) {
Assert.fail("unequal strings "+testValue+" != "+refValue);
}
}
private static void compareAsFloatArrays(String message, String refValue,
String testValue, double eps) {
Error ee = null;
try {
try {
RealArray testArray = new RealArray(testValue);
RealArray refArray = new RealArray(refValue);
assertEquals(message, testArray, refArray, eps);
} catch (NumberFormatException e) {
Assert.assertEquals(message + " String ", refValue, testValue);
}
} catch (ComparisonFailure e) {
ee = e;
} catch (AssertionError e) {
ee = e;
}
if (ee != null) {
throw new RuntimeException("["+testValue+"] != ["+refValue+"]" ,ee);
}
}
private static Element stripWhite(Element refNode) {
refNode = new Element(refNode);
XMLUtil.removeWhitespaceNodes(refNode);
return refNode;
}
public static void alwaysFail(String message) {
Assert.fail("should always throw " + message);
}
// ====================== STML and Euclid ===================
public static String testEquals(String message, double[] a, double[] b, double eps) {
String msg = testEquals(a, b, eps);
return (msg == null) ? null : message+"; "+msg;
}
// Real2
/**
* returns a message if arrays differ.
*
* @param a array to compare
* @param b array to compare
* @param eps tolerance
* @return null if arrays are equal else indicative message
*/
public static String testEquals(Real2 a, Real2 b, double eps) {
String s = null;
if (a == null) {
s = "a is null";
} else if (b == null) {
s = "b is null";
} else {
if (!Real.isEqual(a.x, b.x, eps) ||
!Real.isEqual(a.y, b.y, eps)) {
s = ""+a+" != "+b;
}
}
return s;
}
// double arrays and related
/**
* Asserts equality of double arrays.
*
* checks for non-null, then equality of length, then individual elements
*
* @param message
* @param a
* expected array
* @param b
* actual array
* @param eps
* tolerance for agreement
*/
public static void assertEquals(String message, double[] a, double[] b,
double eps) {
String s = testEquals(a, b, eps);
if (s != null) {
Assert.fail(message + "; " + s);
}
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param test
* array must be of length 4
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, double[] test, Plane3 expected,
double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertEquals("must be of length 4", 4, test.length);
Assert.assertNotNull("ref should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
TestUtils.assertEquals(msg, test, expected.getArray(), epsilon);
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param test
* array must be of length 3
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, double[] test, Point3 expected,
double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertEquals("must be of length 3", 3, test.length);
Assert.assertNotNull("ref should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
TestUtils.assertEquals(msg, test, expected.getArray(), epsilon);
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param test
* array must be of length 3
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, double[] test,
Point3Vector expected, double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("expected should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
Assert.assertEquals("must be of equal length ", test.length, expected
.getArray().length);
TestUtils.assertEquals(msg, test, expected.getArray(), epsilon);
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param test
* array must be of length 2
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, double[] test, Real2 expected,
double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertEquals("must be of length 2", 2, test.length);
Assert.assertNotNull("ref should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
TestUtils.assertEquals(msg, test, expected.getXY(), epsilon);
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param test
* array must be of length 3
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, double[] test,
Real2Vector expected, double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("expected should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
Assert.assertEquals("must be of equal length ", test.length, expected
.getXY().getArray().length);
TestUtils.assertEquals(msg, test, expected.getXY().getArray(), epsilon);
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param test
* array must be of length 3
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, double[] test,
RealArray expected, double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("expected should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
Assert.assertEquals("must be of equal length ", test.length, expected
.getArray().length);
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param test
* 16 values
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, double[] test,
Transform2 expected, double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertEquals("test should have 16 elements (" + msg + STMLConstants.S_RBRAK,
9, test.length);
Assert.assertNotNull("ref should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
TestUtils.assertEquals(msg, test, expected.getMatrixAsArray(), epsilon);
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param test
* 16 values
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, double[] test,
Transform3 expected, double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertEquals("test should have 16 elements (" + msg + STMLConstants.S_RBRAK,
16, test.length);
Assert.assertNotNull("ref should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
TestUtils.assertEquals(msg, test, expected.getMatrixAsArray(), epsilon);
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param test
* array must be of length 3
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, double[] test,
Vector3 expected, double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertEquals("must be of length 3", 3, test.length);
Assert.assertNotNull("expected should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
TestUtils.assertEquals(msg, test, expected.getArray(), epsilon);
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param rows
* @param test
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, int rows, double[] test,
RealSquareMatrix expected, double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("ref should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
Assert.assertEquals("rows should be equal (" + msg + STMLConstants.S_RBRAK, rows,
expected.getRows());
TestUtils.assertEquals(msg, test, expected.getMatrixAsArray(), epsilon);
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param rows
* @param cols
* @param test
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, int rows, int cols,
double[] test, RealMatrix expected, double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("ref should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
Assert.assertEquals("rows should be equal (" + msg + STMLConstants.S_RBRAK, rows,
expected.getRows());
Assert.assertEquals("columns should be equal (" + msg + STMLConstants.S_RBRAK, cols,
expected.getCols());
TestUtils.assertEquals(msg, test, expected.getMatrixAsArray(), epsilon);
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param rows
* @param cols
* @param test
* @param expected
*/
public static void assertEquals(String msg, int rows, int cols, int[] test,
IntMatrix expected) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("ref should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
Assert.assertEquals("rows should be equal (" + msg + STMLConstants.S_RBRAK, rows,
expected.getRows());
Assert.assertEquals("columns should be equal (" + msg + STMLConstants.S_RBRAK, cols,
expected.getCols());
Assert.assertEquals(msg, test, expected.getMatrixAsArray());
}
/**
* Asserts equality of int arrays.
*
* checks for non-null, then equality of length, then individual elements
*
* @param message
* @param a
* expected array
* @param b
* actual array
*/
public static void assertEquals(String message, int[] a, int[] b) {
String s = testEquals(a, b);
if (s != null) {
Assert.fail(message + "; " + s);
}
}
/**
* equality test. true if both args not null and equal
*
* @param msg
* message
* @param test
* @param expected
*/
public static void assertEquals(String msg, int[] test, IntArray expected) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("expected should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
Assert.assertEquals("must be of equal length ", test.length, expected
.getArray().length);
Assert.assertEquals(msg, test, expected.getArray());
}
/**
* equality test. true if both args not null and equal
*
* @param msg
* message
* @param test
* @param expected
*/
public static void assertEquals(String msg, int[] test, IntSet expected) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("expected should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
Assert.assertEquals("must be of equal length ", test.length, expected
.getElements().length);
Assert.assertEquals(msg, test, expected.getElements());
}
/**
* equality test. true if both args not null and equal
*
* @param msg
* message
* @param test
* @param expected
*/
public static void assertEquals(String msg, IntArray test, IntArray expected) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("expected should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
Assert.assertEquals(msg, test.getArray(), expected.getArray());
}
/**
* equality test. true if both args not null and equal within epsilon and
* rows are present and equals and columns are present and equals
*
* @param msg
* message
* @param test
* @param expected
*/
public static void assertEquals(String msg, IntMatrix test,
IntMatrix expected) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("expected should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
Assert.assertNotNull("expected should have columns (" + msg + STMLConstants.S_RBRAK,
expected.getCols());
Assert.assertNotNull("expected should have rows (" + msg + STMLConstants.S_RBRAK,
expected.getRows());
Assert.assertNotNull("test should have columns (" + msg + STMLConstants.S_RBRAK, test
.getCols());
Assert.assertNotNull("test should have rows (" + msg + STMLConstants.S_RBRAK, test
.getRows());
Assert.assertEquals("rows should be equal (" + msg + STMLConstants.S_RBRAK, test
.getRows(), expected.getRows());
Assert.assertEquals("columns should be equal (" + msg + STMLConstants.S_RBRAK, test
.getCols(), expected.getCols());
Assert.assertEquals(msg, test.getMatrixAsArray(), expected.getMatrixAsArray());
}
/**
* equality test. true if both args not null and equal
*
* @param msg
* message
* @param test
* @param expected
*/
public static void assertEquals(String msg, IntSet test, IntSet expected) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("expected should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
Assert.assertEquals(msg, test.getElements(), expected.getElements());
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param test
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, Line3 test, Line3 expected,
double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("ref should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
TestUtils.assertEquals(msg, test.getPoint(), expected.getPoint(), epsilon);
TestUtils.assertEquals(msg, test.getVector(), expected.getVector(), epsilon);
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param test
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, Plane3 test, Plane3 expected,
double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("ref should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
TestUtils.assertEquals(msg, test.getArray(), expected.getArray(), epsilon);
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param test
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, Point3 test, Point3 expected,
double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("ref should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
TestUtils.assertEquals(msg, test.getArray(), expected.getArray(), epsilon);
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param testPoint
* @param testVector
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, Point3 testPoint,
Vector3 testVector, Line3 expected, double epsilon) {
Assert.assertNotNull("testPoint should not be null (" + msg + STMLConstants.S_RBRAK,
testPoint);
Assert.assertNotNull("testVector should not be null (" + msg + STMLConstants.S_RBRAK,
testVector);
Assert.assertNotNull("expected should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
TestUtils.assertEquals(msg, testPoint, expected.getPoint(), epsilon);
TestUtils.assertEquals(msg, testVector, expected.getVector(), epsilon);
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param test
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, Point3Vector test,
Point3Vector expected, double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("expected should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
TestUtils.assertEquals(msg, test.getArray(), expected.getArray(), epsilon);
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param test
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, Real2 test, Real2 expected,
double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("expected should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
TestUtils.assertEquals(msg, test.getXY(), expected.getXY(), epsilon);
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param test
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, Real2Vector expected,
Real2Vector test, double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("expected should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
TestUtils.assertEquals(msg, expected.getXY().getArray(), test.getXY().getArray(),
epsilon);
}
/**
* test ranges for equality.
*
* @param msg
* @param r3ref
* @param r3
* @param epsilon
*/
public static void assertEquals(String msg, Real3Range r3ref,
Real3Range r3, double epsilon) {
TestUtils.assertEquals("xRange", r3.getXRange(), r3ref.getXRange(), epsilon);
TestUtils.assertEquals("yRange", r3.getYRange(), r3ref.getYRange(), epsilon);
TestUtils.assertEquals("zRange", r3.getZRange(), r3ref.getZRange(), epsilon);
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param test
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, RealArray test,
RealArray expected, double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("expected should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
TestUtils.assertEquals(msg, test.getArray(), expected.getArray(), epsilon);
}
/**
* equality test. true if both args not null and equal within epsilon and
* rows are present and equals and columns are present and equals
*
* @param msg
* message
* @param test
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, RealMatrix test,
RealMatrix expected, double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("expected should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
Assert.assertNotNull("expected should have columns (" + msg + STMLConstants.S_RBRAK,
expected.getCols());
Assert.assertNotNull("expected should have rows (" + msg + STMLConstants.S_RBRAK,
expected.getRows());
Assert.assertNotNull("test should have columns (" + msg + STMLConstants.S_RBRAK, test
.getCols());
Assert.assertNotNull("test should have rows (" + msg + STMLConstants.S_RBRAK, test
.getRows());
Assert.assertEquals("rows should be equal (" + msg + STMLConstants.S_RBRAK, test
.getRows(), expected.getRows());
Assert.assertEquals("columns should be equal (" + msg + STMLConstants.S_RBRAK, test
.getCols(), expected.getCols());
TestUtils.assertEquals(msg, test.getMatrixAsArray(), expected.getMatrixAsArray(),
epsilon);
}
/**
* tests equality of ranges.
*
* @param msg
* message
* @param ref
* @param r
* @param epsilon
*/
public static void assertEquals(String msg, RealRange ref, RealRange r,
double epsilon) {
Assert.assertEquals(msg + " min", r.getMin(), ref.getMin(), epsilon);
Assert.assertEquals(msg + " max", r.getMax(), ref.getMax(), epsilon);
}
/**
* equality test. true if both args not null and equal within epsilon and
* rows are present and equals and columns are present and equals
*
* @param msg
* message
* @param test
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, RealSquareMatrix test,
RealSquareMatrix expected, double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("expected should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
Assert.assertNotNull("expected should have columns (" + msg + STMLConstants.S_RBRAK,
expected.getCols());
Assert.assertNotNull("expected should have rows (" + msg + STMLConstants.S_RBRAK,
expected.getRows());
Assert.assertNotNull("test should have columns (" + msg + STMLConstants.S_RBRAK, test
.getCols());
Assert.assertNotNull("test should have rows (" + msg + STMLConstants.S_RBRAK, test
.getRows());
Assert.assertEquals("rows should be equal (" + msg + STMLConstants.S_RBRAK, test
.getRows(), expected.getRows());
Assert.assertEquals("columns should be equal (" + msg + STMLConstants.S_RBRAK, test
.getCols(), expected.getCols());
TestUtils.assertEquals(msg, test.getMatrixAsArray(), expected.getMatrixAsArray(),
epsilon);
}
/**
* Asserts equality of String arrays.
*
* convenience method where test is a whitespace-separated set of tokens
*
* @param message
* @param a
* expected array as space concatenated
* @param b
* actual array may not include nulls
*/
public static void assertEquals(String message, String a, String[] b) {
String[] aa = a.split(EC.S_SPACE);
String s = testEquals(aa, b);
if (s != null) {
Assert.fail(message + "; " + s);
}
}
/**
* Asserts equality of String arrays.
*
* checks for non-null, then equality of length, then individual elements
* equality if individual elements are equal or both elements are null
*
* @param message
* @param a
* expected array may include nulls
* @param b
* actual array may include nulls
*/
public static void assertEquals(String message, String[] a, String[] b) {
String s = testEquals(a, b);
if (s != null) {
Assert.fail(message + "; " + s +
"("+Util.concatenate(a, "~")+" != "+Util.concatenate(b, "~"));
}
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param test
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, Transform2 test,
Transform2 expected, double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("expected should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
TestUtils.assertEquals(msg, test.getMatrixAsArray(), expected.getMatrixAsArray(),
epsilon);
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param test
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, Transform3 test,
Transform3 expected, double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("expected should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
TestUtils.assertEquals(msg, test.getMatrixAsArray(), expected.getMatrixAsArray(),
epsilon);
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param test
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, Vector2 test, Vector2 expected,
double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("expected should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
TestUtils.assertEquals(msg, test.getXY(), expected.getXY(), epsilon);
}
/**
* equality test. true if both args not null and equal within epsilon
*
* @param msg
* message
* @param test
* @param expected
* @param epsilon
*/
public static void assertEquals(String msg, Vector3 test, Vector3 expected,
double epsilon) {
Assert.assertNotNull("test should not be null (" + msg + STMLConstants.S_RBRAK, test);
Assert.assertNotNull("expected should not be null (" + msg + STMLConstants.S_RBRAK,
expected);
TestUtils.assertEquals(msg, test.getArray(), expected.getArray(), epsilon);
}
/**
* tests 2 XML objects for equality using canonical XML.
*
* @param message
* @param refNode
* first node
* @param testNode
* second node
* @param stripWhite
* if true remove w/s nodes
*/
public static void assertEqualsCanonically(String message, Element refNode,
Element testNode, boolean stripWhite) {
assertEqualsCanonically(message, refNode, testNode, stripWhite, true);
}
/**
* tests 2 XML objects for equality using canonical XML.
*
* @param message
* @param refXMLString
* @param testNode
* second node
* @param stripWhite
* if true remove w/s nodes
*/
public static void assertEqualsCanonically(String message, String refXMLString,
Element testNode, boolean stripWhite) {
assertEqualsCanonically(message, TestUtils.parseValidString(refXMLString), testNode, stripWhite, true);
}
//
// public static void assertEqualsCanonically(String message, STMLMap refNode, STMLMap testNode) {
// Assert.assertEquals("from refs", new HashSet(refNode.getFromRefs()), new HashSet(testNode.getFromRefs()));
// Assert.assertEquals("to refs", new HashSet(refNode.getToRefs()), new HashSet(testNode.getToRefs()));
// for (String fromRef : refNode.getFromRefs()) {
// String toRef = refNode.getToRef(fromRef);
// Assert.assertEquals("from/to refs", toRef, testNode.getToRef(fromRef));
// }
// }
/**
* tests 2 XML objects for equality using canonical XML.
*
* @param message
* @param refNode
* first node
* @param testNode
* second node
* @param stripWhite
* if true remove w/s nodes
*/
private static void assertEqualsCanonically(String message,
Element refNode, Element testNode, boolean stripWhite,
boolean reportError) throws Error {
if (stripWhite) {
refNode = stripWhite(refNode);
testNode = stripWhite(testNode);
}
Error ee = null;
try {
XOMTestCase.assertEquals(message, refNode, testNode);
} catch (ComparisonFailure e) {
ee = e;
} catch (AssertionFailedError e) {
ee = e;
}
if (ee != null) {
if (reportError) {
reportXMLDiffInFull(message, ee.getMessage(), refNode, testNode);
} else {
throw (ee);
}
}
}
/**
* compares two XML nodes and checks float near-equivalence (can also be
* used for documents without floats) uses CMLXOMTestUtils.assertEqualsCanonically and only
* uses PMR code if fails
*
* @param message
* @param refNode
* @param testNode
* @param eps
*/
public static void assertEqualsIncludingFloat(String message, Node refNode,
Node testNode, boolean stripWhite, double eps, boolean report) {
if (stripWhite && refNode instanceof Element
&& testNode instanceof Element) {
refNode = stripWhite((Element) refNode);
testNode = stripWhite((Element) testNode);
}
try {
assertEqualsIncludingFloat(message, refNode, testNode, eps);
} catch (RuntimeException e) {
if (report) {
reportXMLDiffInFull(message, e.getMessage(), refNode, testNode);
}
}
}
/**
* Asserts non equality of double arrays.
*
* checks for non-null, then equality of length, then individual elements
*
* @param message
* @param a
* expected array
* @param b
* actual array
* @param eps
* tolerance for agreement
*/
public static void assertNotEquals(String message, double[] a, double[] b,
double eps) {
String s = testEquals(a, b, eps);
if (s == null) {
Assert.fail(message + "; arrays are equal");
}
}
/**
* Asserts non equality of double arrays.
*
* checks for non-null, then equality of length, then individual elements
*
* @param message
* @param a
* expected array
* @param b
* actual array
*/
public static void assertNotEquals(String message, int[] a, int[] b) {
String s = testEquals(a, b);
if (s == null) {
Assert.fail(message + "; arrays are equal");
}
}
/**
* Asserts non equality of String arrays.
*
* checks for non-null, then equality of length, then individual elements
*
* @param message
* @param a
* expected array
* @param b
* actual array
*/
public static void assertNotEquals(String message, String[] a, String[] b) {
String s = testEquals(a, b);
if (s == null) {
Assert.fail(message + "; arrays are equal");
}
}
/**
* tests 2 XML objects for non-equality using canonical XML.
*
* @param message
* @param node1
* first node
* @param node2
* second node
*/
public static void assertNotEqualsCanonically(String message, Node node1,
Node node2) {
try {
Assert.assertEquals(message, node1, node2);
String s1 = XMLUtil.getCanonicalString(node1);
String s2 = XMLUtil.getCanonicalString(node2);
Assert.fail(message + "nodes should be different " + s1 + " != "
+ s2);
} catch (ComparisonFailure e) {
} catch (AssertionFailedError e) {
}
}
public static void assertObjectivelyEquals(String message, double[] a,
double[] b, double eps) {
String s = null;
if (a == null) {
s = "a is null";
} else if (b == null) {
s = "b is null";
} else if (a.length != b.length) {
s = "unequal arrays: " + a.length + STMLConstants.S_SLASH + b.length;
} else {
for (int i = 0; i < a.length; i++) {
if (!(((Double) a[i]).equals(b[i]) || !Real.isEqual(a[i], b[i],
eps))) {
s = "unequal element at (" + i + "), " + a[i] + " != "
+ b[i];
break;
}
}
}
if (s != null) {
Assert.fail(message + "; " + s);
}
}
/**
* test the writeHTML method of element.
*
* @param element
* to test
* @param expected
* HTML string
*/
public static void assertWriteHTML(STMLElement element, String expected) {
StringWriter sw = new StringWriter();
try {
element.writeHTML(sw);
sw.close();
} catch (IOException e) {
Assert.fail("should not throw " + e);
}
String s = sw.toString();
Assert.assertEquals("HTML output ", expected, s);
}
/**
* used by Assert routines. copied from Assert
*
* @param message
* prepends if not null
* @param expected
* @param actual
* @return message
*/
public static String getAssertFormat(String message, Object expected,
Object actual) {
String formatted = "";
if (message != null) {
formatted = message + STMLConstants.S_SPACE;
}
return formatted + "expected:<" + expected + "> but was:<" + actual
+ ">";
}
public static void neverFail(Exception e) {
Assert.fail("should never throw " + e);
}
public static void neverThrow(Exception e) {
throw new EuclidRuntimeException("should never throw " + e);
}
/**
* convenience method to parse test file. uses resource
*
* @param filename
* relative to classpath
* @return root element
*/
public static Element parseValidFile(String filename) {
Element root = null;
try {
URL url = Util.getResource(filename);
root = new Builder().build(new File(url.toURI()))
.getRootElement();
} catch (Exception e) {
e.printStackTrace();
}
return root;
}
/**
* convenience method to parse test file.
* @param file relative to classpath
* @return root element
*/
public static Element parseValidFile(File file) {
Element root = null;
try {
root = new Builder().build(new FileInputStream(file)).getRootElement();
} catch (Exception e) {
throw new RuntimeException("BUG ", e);
}
return root;
}
/**
* convenience method to parse test string.
*
* @param s
* xml string (assumed valid)
* @return root element
*/
public static Element parseValidString(String s) {
Element element = null;
if (s == null) {
throw new RuntimeException("NULL VALID JAVA_STRING");
}
try {
element = XMLUtil.parseXML(s);
} catch (Exception e) {
e.printStackTrace();
System.err.println("ERROR " + e + e.getMessage() + "..."
+ s.substring(0, Math.min(100, s.length())));
Util.BUG(e);
}
return element;
}
static protected void reportXMLDiff(String message, String errorMessage,
Node refNode, Node testNode) {
Assert.fail(message + " ~ " + errorMessage);
}
static protected void reportXMLDiffInFull(String message,
String errorMessage, Node refNode, Node testNode) {
try {
System.err.println("Error: "+errorMessage);
System.err.println("==========XMLDIFF reference=========");
XMLUtil.debug((Element) refNode, System.err, 2);
System.err.println("------------test---------------------");
String s = testNode.toXML().replace("><", ">\n<");
System.err.println(s);
System.err.println("==============" + message
+ "===================");
} catch (Exception e) {
throw new RuntimeException(e);
}
Assert.fail(message + " ~ " + errorMessage);
}
/**
* returns a message if arrays differ.
*
* @param a
* array to compare
* @param b
* array to compare
* @param eps
* tolerance
* @return null if arrays are equal else indicative message
*/
static String testEquals(double[] a, double[] b, double eps) {
String s = null;
if (a == null) {
s = "a is null";
} else if (b == null) {
s = "b is null";
} else if (a.length != b.length) {
s = "unequal arrays: " + a.length + STMLConstants.S_SLASH + b.length;
} else {
for (int i = 0; i < a.length; i++) {
if (!Real.isEqual(a[i], b[i], eps)) {
s = "unequal element at (" + i + "), " + a[i] + " != "
+ b[i];
break;
}
}
}
return s;
}
/**
* returns a message if arrays of arrays differ.
*
* @param a
* array to compare
* @param b
* array to compare
* @param eps
* tolerance
* @return null if array are equal else indicative message
*/
static String testEquals(double[][] a, double[][] b, double eps) {
String s = null;
if (a == null) {
s = "a is null";
} else if (b == null) {
s = "b is null";
} else if (a.length != b.length) {
s = "unequal arrays: " + a.length + STMLConstants.S_SLASH + b.length;
} else {
for (int i = 0; i < a.length; i++) {
if (a[i].length != b[i].length) {
s = "row (" + i + ") has unequal lengths: " + a[i].length
+ STMLConstants.S_SLASH + b[i].length;
break;
}
for (int j = 0; j < a[i].length; j++) {
if (!Real.isEqual(a[i][j], b[i][j], eps)) {
s = "unequal element at (" + i + ", " + j + "), ("
+ a[i][j] + " != " + b[i][j] + STMLConstants.S_RBRAK;
break;
}
}
}
}
return s;
}
/**
* compare integer arrays.
*
* @param a
* @param b
* @return message or null
*/
public static String testEquals(int[] a, int[] b) {
String s = null;
if (a == null) {
s = "a is null";
} else if (b == null) {
s = "b is null";
} else if (a.length != b.length) {
s = "unequal arrays: " + a.length + STMLConstants.S_SLASH + b.length;
} else {
for (int i = 0; i < a.length; i++) {
if (a[i] != b[i]) {
s = "unequal element (" + i + "), " + a[i] + " != " + b[i];
break;
}
}
}
return s;
}
/**
* match arrays. error is a == null or b == null or a.length != b.length or
* a[i] != b[i] nulls match
*
* @param a
* @param b
* @return message if errors else null
*/
public static String testEquals(String[] a, String[] b) {
String s = null;
if (a == null) {
s = "a is null";
} else if (b == null) {
s = "b is null";
} else if (a.length != b.length) {
s = "unequal arrays: " + a.length + STMLConstants.S_SLASH + b.length;
} else {
for (int i = 0; i < a.length; i++) {
if (a[i] == null && b[i] == null) {
// both null, match
} else if (a[i] == null || b[i] == null || !a[i].equals(b[i])) {
s = "unequal element (" + i + "), expected: " + a[i]
+ " found: " + b[i];
break;
}
}
}
return s;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy