327 lines
11 KiB
Java
327 lines
11 KiB
Java
package validation;
|
|
|
|
import java.io.File;
|
|
import java.io.FileNotFoundException;
|
|
import java.net.URL;
|
|
|
|
import javax.xml.XMLConstants;
|
|
import javax.xml.parsers.DocumentBuilder;
|
|
import javax.xml.parsers.DocumentBuilderFactory;
|
|
import javax.xml.transform.Result;
|
|
import javax.xml.transform.Source;
|
|
import javax.xml.transform.dom.DOMResult;
|
|
import javax.xml.transform.dom.DOMSource;
|
|
import javax.xml.validation.Schema;
|
|
import javax.xml.validation.SchemaFactory;
|
|
import javax.xml.validation.Validator;
|
|
|
|
|
|
import com.sun.org.apache.xerces.internal.dom.PSVIElementNSImpl;
|
|
import com.sun.org.apache.xerces.internal.impl.Constants;
|
|
import com.sun.org.apache.xerces.internal.impl.xs.SchemaGrammar;
|
|
import com.sun.org.apache.xerces.internal.xs.ElementPSVI;
|
|
import com.sun.org.apache.xerces.internal.xs.ItemPSVI;
|
|
import com.sun.org.apache.xerces.internal.xs.XSElementDeclaration;
|
|
import com.sun.org.apache.xerces.internal.xs.XSTypeDefinition;
|
|
import java.security.Policy;
|
|
import javax.xml.transform.stream.StreamSource;
|
|
import org.w3c.dom.Document;
|
|
import org.w3c.dom.Node;
|
|
|
|
public abstract class BaseTest {
|
|
protected final static String ROOT_TYPE = Constants.XERCES_PROPERTY_PREFIX
|
|
+ Constants.ROOT_TYPE_DEFINITION_PROPERTY;
|
|
|
|
protected final static String IGNORE_XSI_TYPE = Constants.XERCES_FEATURE_PREFIX
|
|
+ Constants.IGNORE_XSI_TYPE_FEATURE;
|
|
|
|
protected final static String ID_IDREF_CHECKING = Constants.XERCES_FEATURE_PREFIX
|
|
+ Constants.ID_IDREF_CHECKING_FEATURE;
|
|
|
|
protected final static String IDC_CHECKING = Constants.XERCES_FEATURE_PREFIX
|
|
+ Constants.IDC_CHECKING_FEATURE;
|
|
|
|
protected final static String UNPARSED_ENTITY_CHECKING = Constants.XERCES_FEATURE_PREFIX
|
|
+ Constants.UNPARSED_ENTITY_CHECKING_FEATURE;
|
|
|
|
protected final static String USE_GRAMMAR_POOL_ONLY = Constants.XERCES_FEATURE_PREFIX
|
|
+ Constants.USE_GRAMMAR_POOL_ONLY_FEATURE;
|
|
|
|
protected final static String DYNAMIC_VALIDATION = Constants.XERCES_FEATURE_PREFIX
|
|
+ Constants.DYNAMIC_VALIDATION_FEATURE;
|
|
|
|
protected final static String DOCUMENT_CLASS_NAME = Constants.XERCES_PROPERTY_PREFIX
|
|
+ Constants.DOCUMENT_CLASS_NAME_PROPERTY;
|
|
|
|
public static boolean isWindows = false;
|
|
static {
|
|
if (System.getProperty("os.name").indexOf("Windows")>-1) {
|
|
isWindows = true;
|
|
}
|
|
};
|
|
|
|
protected Schema schema;
|
|
protected Validator fValidator;
|
|
|
|
protected SpecialCaseErrorHandler fErrorHandler;
|
|
|
|
protected DocumentBuilder builder;
|
|
protected Document fDocument;
|
|
|
|
protected ElementPSVI fRootNode;
|
|
protected URL fDocumentURL;
|
|
protected URL fSchemaURL;
|
|
|
|
static String errMessage;
|
|
|
|
int passed = 0, failed = 0;
|
|
private boolean hasSM;
|
|
private Policy orig;
|
|
|
|
protected abstract String getSchemaFile();
|
|
|
|
protected abstract String getXMLDocument();
|
|
|
|
public BaseTest(String name) {
|
|
fErrorHandler = new SpecialCaseErrorHandler(getRelevantErrorIDs());
|
|
}
|
|
|
|
protected void setUp() throws Exception {
|
|
if (System.getSecurityManager() != null) {
|
|
hasSM = true;
|
|
System.setSecurityManager(null);
|
|
}
|
|
|
|
orig = Policy.getPolicy();
|
|
|
|
DocumentBuilderFactory docFactory = DocumentBuilderFactory
|
|
.newInstance();
|
|
docFactory.setAttribute(DOCUMENT_CLASS_NAME,
|
|
"com.sun.org.apache.xerces.internal.dom.PSVIDocumentImpl");
|
|
docFactory.setNamespaceAware(true);
|
|
builder = docFactory.newDocumentBuilder();
|
|
// build the location URL of the document
|
|
String filepath = System.getProperty("test.src", ".");
|
|
String packageDir = this.getClass().getPackage().getName().replace('.',
|
|
'/');
|
|
String documentPath = filepath + "/" + packageDir + "/" + getXMLDocument();
|
|
String schemaPath = filepath + "/" + packageDir + "/" + getSchemaFile();
|
|
|
|
if (isWindows) {
|
|
fDocumentURL = new URL("file:/" + documentPath);
|
|
fSchemaURL = new URL("file:/" + schemaPath);
|
|
} else {
|
|
fDocumentURL = new URL("file:" + documentPath);
|
|
fSchemaURL = new URL("file:" + schemaPath);
|
|
}
|
|
if (fDocumentURL == null) {
|
|
throw new FileNotFoundException("Couldn't find xml file for test: " + documentPath);
|
|
}
|
|
|
|
SchemaFactory sf = SchemaFactory
|
|
.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
|
|
sf.setFeature(USE_GRAMMAR_POOL_ONLY, getUseGrammarPoolOnly());
|
|
|
|
if (fSchemaURL == null) {
|
|
throw new FileNotFoundException("Couldn't find schema file for test: " + schemaPath);
|
|
}
|
|
schema = sf.newSchema(fSchemaURL);
|
|
|
|
// String schemaPath = "./jaxp-ri/src/unit-test/apache/xerces/jdk8037819/" + getSchemaFile();
|
|
// Schema schema = sf.newSchema(new StreamSource(new File(schemaPath)));
|
|
}
|
|
|
|
protected void tearDown() throws Exception {
|
|
System.setSecurityManager(null);
|
|
Policy.setPolicy(orig);
|
|
if (hasSM) {
|
|
System.setSecurityManager(new SecurityManager());
|
|
}
|
|
|
|
builder = null;
|
|
schema = null;
|
|
fRootNode = null;
|
|
fErrorHandler.reset();
|
|
System.out.println("\nNumber of tests passed: " + passed);
|
|
System.out.println("Number of tests failed: " + failed + "\n");
|
|
|
|
if (errMessage != null) {
|
|
throw new RuntimeException(errMessage);
|
|
}
|
|
}
|
|
|
|
protected void validateDocument() throws Exception {
|
|
Source source = new DOMSource(fDocument);
|
|
source.setSystemId(fDocumentURL.toExternalForm());
|
|
Result result = new DOMResult(fDocument);
|
|
|
|
fValidator.validate(source, result);
|
|
}
|
|
|
|
protected void validateFragment() throws Exception {
|
|
Source source = new DOMSource((Node) fRootNode);
|
|
source.setSystemId(fDocumentURL.toExternalForm());
|
|
Result result = new DOMResult((Node) fRootNode);
|
|
fValidator.validate(source, result);
|
|
}
|
|
|
|
protected void reset() throws Exception {
|
|
// fDocument = builder.parse(new File("./jaxp-ri/src/unit-test/apache/xerces/jdk8037819/" + getXMLDocument()));
|
|
fDocument = builder.parse(fDocumentURL.toExternalForm());
|
|
fRootNode = (ElementPSVI) fDocument.getDocumentElement();
|
|
fValidator = schema.newValidator();
|
|
fErrorHandler.reset();
|
|
fValidator.setErrorHandler(fErrorHandler);
|
|
fValidator.setFeature(DYNAMIC_VALIDATION, false);
|
|
}
|
|
|
|
protected PSVIElementNSImpl getChild(int n) {
|
|
int numFound = 0;
|
|
Node child = ((Node) fRootNode).getFirstChild();
|
|
while (child != null) {
|
|
if (child.getNodeType() == Node.ELEMENT_NODE) {
|
|
numFound++;
|
|
if (numFound == n) {
|
|
return (PSVIElementNSImpl) child;
|
|
}
|
|
}
|
|
child = child.getNextSibling();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
protected String[] getRelevantErrorIDs() {
|
|
return new String[] {};
|
|
}
|
|
|
|
protected boolean getUseGrammarPoolOnly() {
|
|
return false;
|
|
}
|
|
|
|
// specialized asserts
|
|
|
|
protected void assertValidity(short expectedValidity, short actualValidity) {
|
|
String expectedString = expectedValidity == ItemPSVI.VALIDITY_VALID ? "valid"
|
|
: (expectedValidity == ItemPSVI.VALIDITY_INVALID ? "invalid"
|
|
: "notKnown");
|
|
String actualString = actualValidity == ItemPSVI.VALIDITY_VALID ? "valid"
|
|
: (actualValidity == ItemPSVI.VALIDITY_INVALID ? "invalid"
|
|
: "notKnown");
|
|
String message = "{validity} was <" + actualString
|
|
+ "> but it should have been <" + expectedString + ">";
|
|
assertEquals(message, expectedValidity, actualValidity);
|
|
}
|
|
|
|
protected void assertValidationAttempted(short expectedAttempted,
|
|
short actualAttempted) {
|
|
String expectedString = expectedAttempted == ItemPSVI.VALIDATION_FULL ? "full"
|
|
: (expectedAttempted == ItemPSVI.VALIDATION_PARTIAL ? "partial"
|
|
: "none");
|
|
String actualString = actualAttempted == ItemPSVI.VALIDATION_FULL ? "full"
|
|
: (actualAttempted == ItemPSVI.VALIDATION_PARTIAL ? "partial"
|
|
: "none");
|
|
String message = "{validity} was <" + actualString
|
|
+ "> but it should have been <" + expectedString + ">";
|
|
assertEquals(message, expectedAttempted, actualAttempted);
|
|
}
|
|
|
|
protected void assertElementName(String expectedName, String actualName) {
|
|
assertEquals("Local name of element declaration is wrong.",
|
|
expectedName, actualName);
|
|
}
|
|
|
|
protected void assertElementNull(XSElementDeclaration elem) {
|
|
assertNull("Element declaration should be null.", elem);
|
|
}
|
|
|
|
protected void assertElementNamespace(String expectedName, String actualName) {
|
|
assertEquals("Namespace of element declaration is wrong.",
|
|
expectedName, actualName);
|
|
}
|
|
|
|
protected void assertElementNamespaceNull(String actualName) {
|
|
assertNull("Local name of element declaration should be null.",
|
|
actualName);
|
|
}
|
|
|
|
protected void assertTypeName(String expectedName, String actualName) {
|
|
assertEquals("Local name of type definition is wrong.", expectedName,
|
|
actualName);
|
|
}
|
|
|
|
protected void assertTypeNull(XSTypeDefinition type) {
|
|
assertNull("Type definition should be null.", type);
|
|
}
|
|
|
|
protected void assertTypeNamespace(String expectedName, String actualName) {
|
|
assertEquals("Namespace of type definition is wrong.", expectedName,
|
|
actualName);
|
|
}
|
|
|
|
protected void assertTypeNamespaceNull(String actualName) {
|
|
assertNull("Namespace of type definition should be null.", actualName);
|
|
}
|
|
|
|
protected void assertError(String error) {
|
|
assertTrue("Error <" + error + "> should have occured, but did not.",
|
|
fErrorHandler.specialCaseFound(error));
|
|
}
|
|
|
|
protected void assertNoError(String error) {
|
|
assertFalse("Error <" + error
|
|
+ "> should not have occured (but it did)", fErrorHandler
|
|
.specialCaseFound(error));
|
|
}
|
|
|
|
protected void assertAnyType(XSTypeDefinition type) {
|
|
assertEquals("Type is supposed to be anyType", SchemaGrammar.fAnyType,
|
|
type);
|
|
}
|
|
|
|
void assertEquals(String msg, Object expected, Object actual) {
|
|
if (!expected.equals(actual)) {
|
|
fail(msg + " Expected: " + expected + " Actual: " + actual);
|
|
} else {
|
|
success(null);
|
|
}
|
|
}
|
|
void assertNull(String msg, Object value) {
|
|
if (value != null) {
|
|
fail(msg);
|
|
} else {
|
|
success(null);
|
|
}
|
|
}
|
|
public void assertTrue(String msg, boolean value) {
|
|
if (!value) {
|
|
fail(msg);
|
|
} else {
|
|
success(null);
|
|
}
|
|
}
|
|
public void assertFalse(String msg, boolean value) {
|
|
if (value) {
|
|
fail(msg);
|
|
} else {
|
|
success(null);
|
|
}
|
|
}
|
|
public void fail(String errMsg) {
|
|
if (errMessage == null) {
|
|
errMessage = errMsg;
|
|
} else {
|
|
errMessage = errMessage + "\n" + errMsg;
|
|
}
|
|
failed++;
|
|
}
|
|
|
|
public void success(String msg) {
|
|
passed++;
|
|
if (msg != null) {
|
|
if (msg.length() != 0) {
|
|
System.out.println(msg);
|
|
}
|
|
}
|
|
}
|
|
}
|