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