src/test/java/ValidatingXSRTests/detailed/ValidatingXmlStreamReaderTests.java - xmlbeans - Git at Google


 /*   Copyright 2004 The Apache Software Foundation
  *
  *   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 ValidatingXSRTests.detailed;

 import com.foo.sample.HeadingDocument;
 import org.apache.xmlbeans.SchemaType;
 import org.apache.xmlbeans.XmlBeans;
 import org.apache.xmlbeans.impl.validator.ValidatingXMLStreamReader;
 import org.junit.Assert;
 import org.junit.Ignore;
 import org.junit.Test;
 import org.openuri.test.location.LocationDocument;
 import org.openuri.test.mixedContent.LetterDocument;
 import org.openuri.test.mixedContent.NoMixedDocument;
 import org.openuri.test.person.Name;
 import org.openuri.test.person.PersonDocument;
 import org.openuri.test.person.PersonType;
 import tools.util.JarUtil;

 import javax.xml.stream.XMLInputFactory;
 import javax.xml.stream.XMLStreamException;
 import javax.xml.stream.XMLStreamReader;
 import javax.xml.stream.events.XMLEvent;
 import javax.xml.stream.util.StreamReaderDelegate;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.StringReader;
 import java.util.ArrayList;
 import java.util.Collection;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;

 // Schema Imports


 public class ValidatingXmlStreamReaderTests {

     // Base variable
     static String casesLoc = "xbean/ValidatingStream/";

     //////////////////////////////////////////////////////////////////////
     // Tests

     // NOTE: Tests that use getCasesFile are reading files
     //       from cases/qatest/files/xbean
     //       Tests that use getResourceFromJar are getting the contents of
     //       the file in the same location, but packaged into xmlcases.jar
     //       SO, any change to the xml files for these tests will not be
     //       reflected till they make it into xmlcases.jar. (ant build.xmlcases)
     @Test
     public void testDocWithNoSchema() throws Exception {
         checkDocIsInvalid(getCasesFile(casesLoc + "po.xml"), null);
     }

     @Test
     public void testValidLocationDoc() throws Exception {
         checkDocIsValid(getCasesFile(casesLoc + "location.xml"), null);
     }

     @Test
     public void testInvalidLocationDoc() throws Exception {
         checkDocIsInvalid(getCasesFile(casesLoc + "location-inv.xml"), LocationDocument.type);
     }

     @Test
     public void testValidPersonDoc() throws Exception {
         checkDocIsValid(getCasesFile(casesLoc + "person.xml"), PersonDocument.type);
     }

     @Test
     public void testInvalidPersonDoc() throws Exception {
         checkDocIsInvalid(getCasesFile(casesLoc + "person-inv.xml"), PersonDocument.type);
     }

     @Test
     public void testValidMixedContentDoc() throws Exception {
         checkDocIsValid(getCasesFile(casesLoc + "mixed-content.xml"),
             LetterDocument.type);
     }

     @Test
     public void testInvalidNomixedContentDoc() throws Exception {
         checkDocIsInvalid(getCasesFile(casesLoc + "nomixed-content-inv.xml"),
             NoMixedDocument.type);
     }

     @Test
     public void testInvalidMissingAttributeDoc() throws Exception {
         checkDocIsInvalid(getCasesFile(casesLoc + "foo-inv.xml"),
             HeadingDocument.type);
     }


     @Test
     public void testContentName() throws Exception {
         String sXml = JarUtil.getResourceFromJar(casesLoc + "person-frag.xml");
         SchemaType type = Name.type;

         assertTrue("Xml-fragment is not valid:\n" + sXml,
             checkContent(sXml, type, true));
     }


     // Same as testContentName.. expect the xml has no chars before the first
     // start element
     @Test
     public void testContentName2() throws Exception {
         String sXml = JarUtil.getResourceFromJar(casesLoc + "person-frag2.xml");
         SchemaType type = Name.type;

         assertTrue("Xml-fragment is not valid:\n" + sXml,
             checkContent(sXml, type, true));
     }

     @Test
     public void testContentSibling() throws Exception {
         String sXml = JarUtil.getResourceFromJar(casesLoc + "person-sibling.xml");
         SchemaType type = PersonType.type;
         assertTrue("Xml-fragment is not valid:\n" + sXml,
             checkContent(sXml, type, true));
     }

     @Test
     public void testInvalidContentSibling() throws Exception {
         String sXml = JarUtil.getResourceFromJar(casesLoc + "person-sibling-inv.xml");
         SchemaType type = PersonType.type;
         assertTrue("Invalid Xml-fragment is getting validated:\n" + sXml,
             !checkContent(sXml, type, true));
     }

     @Test
     public void testValidXsiType() throws Exception {
         String sXml = JarUtil.getResourceFromJar(casesLoc + "person-justname.xml");
         SchemaType type = Name.type;
         assertTrue("Xml-fragment is not valid:\n" + sXml,
             checkContent(sXml, type, true));
     }

     @Test
     public void testInvalidXsiType() throws Exception {
         String sXml = JarUtil.getResourceFromJar(casesLoc + "person-justname-inv.xml");
         SchemaType type = Name.type;
         assertTrue("Invalid Xml-fragment is getting validated:\n" + sXml,
             !checkContent(sXml, type, true));
     }

     @Test
     public void testIncompatibleXsiType() throws Exception {
         String sXml = JarUtil.getResourceFromJar(casesLoc + "person-xsi-inv.xml");
         SchemaType type = Name.type;
         assertTrue("Invalid Xml-fragment is getting validated:\n" + sXml,
             !checkContent(sXml, type, true));
     }

     @Test
     public void testValidMixedContent() throws Exception {
         String sXml = JarUtil.getResourceFromJar(casesLoc + "mixed-content.xml");
         SchemaType type = org.openuri.test.mixedContent.LetterType.type;
         assertTrue("Xml-fragment is not valid:\n" + sXml,
             checkContent(sXml, type, true));
     }

     @Test
     @Ignore
     public void testGlobalAttribute() throws Exception {
         String sXml = JarUtil.getResourceFromJar(casesLoc + "global-attr.xml");

         assertTrue("Global Attribute test failed:\n",
                    checkContent(sXml, null, true));
     }

     // Tests for increasing code-coverage metrics
     @Test
     public void testValXsrReuse() throws Exception {
         Collection errors = new ArrayList();
         File[] xmls = new File[2];
         xmls[0] = getCasesFile(casesLoc + "person.xml");
         xmls[1] = getCasesFile(casesLoc + "person-inv.xml");
         SchemaType type = PersonDocument.type;

         boolean[] ret = runValidator(xmls, type, errors);

         String common = "Test for ValidatingXmlStreamReader reuse failed";
         assertEquals(common + "\nReturn value has more than 2 elements", 2, ret.length);
         assertTrue(common + "\nExpected: true & false. Actual: "
                 + ret[0] + " & " + ret[1],
             ret[0] && !ret[1]);
     }


     public void testIllegalEvent() throws Exception {
         // Will require writing another XSR wrapper.. albeit simple
     }

     /*/
     public void testWalk() throws Exception {
         walkXml(getCasesFile(casesLoc + "global-attr.xml"));
         System.out.println();
         walkXml(getCasesFile(casesLoc + "person-sibling.xml"));
     }
     // */
     //////////////////////////////////////////////////////////////////////
     // Utility Methods
     private void walkXml(File xml) throws Exception {
         XMLStreamReader xr = XMLInputFactory.newInstance().
             createXMLStreamReader(new FileInputStream(xml));

         //xsr.nextTag();
         XmlContentTestXSR xsr = new XmlContentTestXSR(xr);

         while(xsr.hasNext())
         {
             int type = xsr.next();
             System.out.print(type);
             //*
             if (type == XMLEvent.START_ELEMENT)
             {
                 System.out.print("\n" + xsr.getLocalName() + " ");
             }
             if (type == XMLEvent.END_ELEMENT)
             {
                 System.out.println("/" + xsr.getLocalName());
             }
             if (type == XMLEvent.CHARACTERS)
             {
                 char[] arr = xsr.getTextCharacters();
                 String str = new String(arr);
                 System.out.print("Char:" + str + " ");
             }
             //*/
         }
     }

     private boolean runValidator(File xml,
                                  SchemaType type,
                                  Collection errors)
         throws IllegalArgumentException, Exception
     {
         if (errors == null)
             throw new IllegalArgumentException(
                 "Collection object cannot be null");

         XMLStreamReader xsr = XMLInputFactory.newInstance().
             createXMLStreamReader(new FileInputStream(xml));

         ValidatingXMLStreamReader valXsr = new ValidatingXMLStreamReader();
         valXsr.init(xsr,
             false,
             type,
             XmlBeans.typeLoaderForClassLoader(ValidatingXMLStreamReader.class.getClassLoader()),
             null,
             errors);

         // Walk through the xml
         while (valXsr.hasNext())
             valXsr.next();

         return valXsr.isValid();
         //return true;
     }

     // This method is primarily for testing re-use of the ValXSR object.
     // but could come in handy later..
     private boolean[] runValidator(File[] xml,
                                    SchemaType type,
                                    Collection errors)
         throws IllegalArgumentException, Exception
     {
         if (errors == null)
             throw new IllegalArgumentException(
                 "Collection object cannot be null");
         ValidatingXMLStreamReader valXsr = new ValidatingXMLStreamReader();
         boolean[] retArray = new boolean[xml.length];

         for (int i = 0; i < xml.length; i++)
         {
             XMLStreamReader xsr = XMLInputFactory.newInstance().
                 createXMLStreamReader(new FileInputStream(xml[i]));

             valXsr.init(xsr,
                 false,
                 type,
                 XmlBeans.typeLoaderForClassLoader(ValidatingXMLStreamReader.class.getClassLoader()),
                 null,
                 errors);

             // Walk through the xml
             while (valXsr.hasNext())
                 valXsr.next();

             retArray[i] = valXsr.isValid();
         }

         return retArray;
     }

     protected void checkDocIsValid(File file, SchemaType type) throws Exception {
         Collection errors = new ArrayList();
         boolean isValid = runValidator(file, type, errors);

         tools.xml.Utils.printXMLErrors(errors);
         Assert.assertTrue("File '" + file.getName() + "' is invalid.", isValid);
     }


     protected void checkDocIsInvalid(File file, SchemaType type) throws Exception {
         Collection errors = new ArrayList();

         boolean isValid = runValidator(file, type, errors);
         assertTrue("File '" + file.getName() + "' is valid, but was expecting invalid.",
             !isValid);
     }


     public boolean checkContent(String fragment,
                                 SchemaType type,
                                 boolean printErrors) throws Exception {
         XMLStreamReader xsr = XMLInputFactory.newInstance().
             createXMLStreamReader(new StringReader(fragment));

         XmlContentTestXSR cxsr = new XmlContentTestXSR(xsr);
         Collection errors = new ArrayList();

         ValidatingXMLStreamReader valXsr = new ValidatingXMLStreamReader();
         valXsr.init(cxsr,
             false,
             type,
             XmlBeans.typeLoaderForClassLoader(ValidatingXMLStreamReader.class.getClassLoader()),
             null,
             errors);

         // Walk through the xml
         while (valXsr.hasNext())
             valXsr.next();

         if (!valXsr.isValid())
         {
             if (printErrors)
                 tools.xml.Utils.printXMLErrors(errors);
             return false;
         }
         return true;
     }


     private static File getCasesFile(String path)
         throws java.io.IOException
     {
         if (path.length()==0)
             throw new IOException("getCasesFile was called with path of len 0");
         return JarUtil.getResourceFromJarasFile(path);
         //return new File(casesRoot + path);
     }

     /////////////////////////////////////////////////////////////////////////
     // XmlStreamReader extension for content Validation
     //     will not work for Global Attribute
     public class XmlContentTestXSR
         extends StreamReaderDelegate
         implements XMLStreamReader
     {
         private static final int TAGOPEN    = 100;
         private static final int TAGCLOSE   = 101;
         private static final int UNDEFINED  =  99;
         private static final int ATTRIBUTE  = 102;
         private static final int ENDCONTENT = 103;

         int state = -1;
         int depth = -1;
         boolean initialized = false;
         int attributeCount = -1;
         boolean hasAttributes = false;

         // Constructor Wrappers
         public XmlContentTestXSR(XMLStreamReader xsr)
             throws XMLStreamException
         {
             super(xsr);
         }


         public boolean hasNext()
         {
             if (state == UNDEFINED || state == ENDCONTENT)
                 return false;

             if (!initialized)       // next() has not been called yet
                 return true;


             return true;
         }

         public int next()
             throws XMLStreamException
         {
             int _next;
             if (!initialized)
             {
                 // First time next() is called..
                 // Scan for the first XMLEvent.START_ELEMENT
                 _next = UNDEFINED;
                 while ((super.hasNext()) && (_next != XMLEvent.START_ELEMENT))
                     _next = super.next();

                 if (_next != XMLEvent.START_ELEMENT)
                     throw new XMLStreamException(
                         "Could not find a start element");
                 initialized = true;

                 // Now move past the first tag
                 state = TAGOPEN;
                 depth = 1;

                 if ((attributeCount = super.getAttributeCount()) > 0)
                 {
                     // The first element has attributes.. this is part of
                     // the content. So the first event should XMLEvent.ATTRIBUTE
                     _next = XMLEvent.ATTRIBUTE;
                 }
                 else
                 {
                     // return super.next();
                     /*
                     If content is <xml-fragment/> then we will have returned
                     END_ELEMENT above, without ever generating a START_ELEMENT
                     In this case probably we should detect this and return a
                     END_DOCUMENT
                     */
                     _next = super.next();
                     if (_next == XMLEvent.END_ELEMENT)
                     {
                         _next = XMLEvent.END_DOCUMENT;
                         state = ENDCONTENT;
                     }
                 }
                 return _next;
             }

             _next = super.next();
             switch (_next)
             {
                 case XMLEvent.START_ELEMENT:
                     state = TAGOPEN;
                     depth++;
                     break;

                 case XMLEvent.END_ELEMENT:
                     --depth;
                     if (depth < 0 && state == TAGOPEN)
                     {
                         throw new XMLStreamException(
                             "Illegal XML Stream state");
                     }
                     else if (depth == 0 && state == TAGOPEN)
                     {
                         state = ENDCONTENT;
                         // at this point we will return ENDDOCUMENT
                         _next = XMLEvent.END_DOCUMENT;
                     }
                     break;
             }

             return _next;
         }

     }


 }

	/* Copyright 2004 The Apache Software Foundation
	*
	* 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 ValidatingXSRTests.detailed;

	import com.foo.sample.HeadingDocument;
	import org.apache.xmlbeans.SchemaType;
	import org.apache.xmlbeans.XmlBeans;
	import org.apache.xmlbeans.impl.validator.ValidatingXMLStreamReader;
	import org.junit.Assert;
	import org.junit.Ignore;
	import org.junit.Test;
	import org.openuri.test.location.LocationDocument;
	import org.openuri.test.mixedContent.LetterDocument;
	import org.openuri.test.mixedContent.NoMixedDocument;
	import org.openuri.test.person.Name;
	import org.openuri.test.person.PersonDocument;
	import org.openuri.test.person.PersonType;
	import tools.util.JarUtil;

	import javax.xml.stream.XMLInputFactory;
	import javax.xml.stream.XMLStreamException;
	import javax.xml.stream.XMLStreamReader;
	import javax.xml.stream.events.XMLEvent;
	import javax.xml.stream.util.StreamReaderDelegate;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.IOException;
	import java.io.StringReader;
	import java.util.ArrayList;
	import java.util.Collection;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertTrue;

	// Schema Imports


	public class ValidatingXmlStreamReaderTests {

	// Base variable
	static String casesLoc = "xbean/ValidatingStream/";

	//////////////////////////////////////////////////////////////////////
	// Tests

	// NOTE: Tests that use getCasesFile are reading files
	// from cases/qatest/files/xbean
	// Tests that use getResourceFromJar are getting the contents of
	// the file in the same location, but packaged into xmlcases.jar
	// SO, any change to the xml files for these tests will not be
	// reflected till they make it into xmlcases.jar. (ant build.xmlcases)
	@Test
	public void testDocWithNoSchema() throws Exception {
	checkDocIsInvalid(getCasesFile(casesLoc + "po.xml"), null);
	}

	@Test
	public void testValidLocationDoc() throws Exception {
	checkDocIsValid(getCasesFile(casesLoc + "location.xml"), null);
	}

	@Test
	public void testInvalidLocationDoc() throws Exception {
	checkDocIsInvalid(getCasesFile(casesLoc + "location-inv.xml"), LocationDocument.type);
	}

	@Test
	public void testValidPersonDoc() throws Exception {
	checkDocIsValid(getCasesFile(casesLoc + "person.xml"), PersonDocument.type);
	}

	@Test
	public void testInvalidPersonDoc() throws Exception {
	checkDocIsInvalid(getCasesFile(casesLoc + "person-inv.xml"), PersonDocument.type);
	}

	@Test
	public void testValidMixedContentDoc() throws Exception {
	checkDocIsValid(getCasesFile(casesLoc + "mixed-content.xml"),
	LetterDocument.type);
	}

	@Test
	public void testInvalidNomixedContentDoc() throws Exception {
	checkDocIsInvalid(getCasesFile(casesLoc + "nomixed-content-inv.xml"),
	NoMixedDocument.type);
	}

	@Test
	public void testInvalidMissingAttributeDoc() throws Exception {
	checkDocIsInvalid(getCasesFile(casesLoc + "foo-inv.xml"),
	HeadingDocument.type);
	}


	@Test
	public void testContentName() throws Exception {
	String sXml = JarUtil.getResourceFromJar(casesLoc + "person-frag.xml");
	SchemaType type = Name.type;

	assertTrue("Xml-fragment is not valid:\n" + sXml,
	checkContent(sXml, type, true));
	}


	// Same as testContentName.. expect the xml has no chars before the first
	// start element
	@Test
	public void testContentName2() throws Exception {
	String sXml = JarUtil.getResourceFromJar(casesLoc + "person-frag2.xml");
	SchemaType type = Name.type;

	assertTrue("Xml-fragment is not valid:\n" + sXml,
	checkContent(sXml, type, true));
	}

	@Test
	public void testContentSibling() throws Exception {
	String sXml = JarUtil.getResourceFromJar(casesLoc + "person-sibling.xml");
	SchemaType type = PersonType.type;
	assertTrue("Xml-fragment is not valid:\n" + sXml,
	checkContent(sXml, type, true));
	}

	@Test
	public void testInvalidContentSibling() throws Exception {
	String sXml = JarUtil.getResourceFromJar(casesLoc + "person-sibling-inv.xml");
	SchemaType type = PersonType.type;
	assertTrue("Invalid Xml-fragment is getting validated:\n" + sXml,
	!checkContent(sXml, type, true));
	}

	@Test
	public void testValidXsiType() throws Exception {
	String sXml = JarUtil.getResourceFromJar(casesLoc + "person-justname.xml");
	SchemaType type = Name.type;
	assertTrue("Xml-fragment is not valid:\n" + sXml,
	checkContent(sXml, type, true));
	}

	@Test
	public void testInvalidXsiType() throws Exception {
	String sXml = JarUtil.getResourceFromJar(casesLoc + "person-justname-inv.xml");
	SchemaType type = Name.type;
	assertTrue("Invalid Xml-fragment is getting validated:\n" + sXml,
	!checkContent(sXml, type, true));
	}

	@Test
	public void testIncompatibleXsiType() throws Exception {
	String sXml = JarUtil.getResourceFromJar(casesLoc + "person-xsi-inv.xml");
	SchemaType type = Name.type;
	assertTrue("Invalid Xml-fragment is getting validated:\n" + sXml,
	!checkContent(sXml, type, true));
	}

	@Test
	public void testValidMixedContent() throws Exception {
	String sXml = JarUtil.getResourceFromJar(casesLoc + "mixed-content.xml");
	SchemaType type = org.openuri.test.mixedContent.LetterType.type;
	assertTrue("Xml-fragment is not valid:\n" + sXml,
	checkContent(sXml, type, true));
	}

	@Test
	@Ignore
	public void testGlobalAttribute() throws Exception {
	String sXml = JarUtil.getResourceFromJar(casesLoc + "global-attr.xml");

	assertTrue("Global Attribute test failed:\n",
	checkContent(sXml, null, true));
	}

	// Tests for increasing code-coverage metrics
	@Test
	public void testValXsrReuse() throws Exception {
	Collection errors = new ArrayList();
	File[] xmls = new File[2];
	xmls[0] = getCasesFile(casesLoc + "person.xml");
	xmls[1] = getCasesFile(casesLoc + "person-inv.xml");
	SchemaType type = PersonDocument.type;

	boolean[] ret = runValidator(xmls, type, errors);

	String common = "Test for ValidatingXmlStreamReader reuse failed";
	assertEquals(common + "\nReturn value has more than 2 elements", 2, ret.length);
	assertTrue(common + "\nExpected: true & false. Actual: "
	+ ret[0] + " & " + ret[1],
	ret[0] && !ret[1]);
	}


	public void testIllegalEvent() throws Exception {
	// Will require writing another XSR wrapper.. albeit simple
	}

	/*/
	public void testWalk() throws Exception {
	walkXml(getCasesFile(casesLoc + "global-attr.xml"));
	System.out.println();
	walkXml(getCasesFile(casesLoc + "person-sibling.xml"));
	}
	// */
	//////////////////////////////////////////////////////////////////////
	// Utility Methods
	private void walkXml(File xml) throws Exception {
	XMLStreamReader xr = XMLInputFactory.newInstance().
	createXMLStreamReader(new FileInputStream(xml));

	//xsr.nextTag();
	XmlContentTestXSR xsr = new XmlContentTestXSR(xr);

	while(xsr.hasNext())
	{
	int type = xsr.next();
	System.out.print(type);
	//*
	if (type == XMLEvent.START_ELEMENT)
	{
	System.out.print("\n" + xsr.getLocalName() + " ");
	}
	if (type == XMLEvent.END_ELEMENT)
	{
	System.out.println("/" + xsr.getLocalName());
	}
	if (type == XMLEvent.CHARACTERS)
	{
	char[] arr = xsr.getTextCharacters();
	String str = new String(arr);
	System.out.print("Char:" + str + " ");
	}
	//*/
	}
	}

	private boolean runValidator(File xml,
	SchemaType type,
	Collection errors)
	throws IllegalArgumentException, Exception
	{
	if (errors == null)
	throw new IllegalArgumentException(
	"Collection object cannot be null");

	XMLStreamReader xsr = XMLInputFactory.newInstance().
	createXMLStreamReader(new FileInputStream(xml));

	ValidatingXMLStreamReader valXsr = new ValidatingXMLStreamReader();
	valXsr.init(xsr,
	false,
	type,
	XmlBeans.typeLoaderForClassLoader(ValidatingXMLStreamReader.class.getClassLoader()),
	null,
	errors);

	// Walk through the xml
	while (valXsr.hasNext())
	valXsr.next();

	return valXsr.isValid();
	//return true;
	}

	// This method is primarily for testing re-use of the ValXSR object.
	// but could come in handy later..
	private boolean[] runValidator(File[] xml,
	SchemaType type,
	Collection errors)
	throws IllegalArgumentException, Exception
	{
	if (errors == null)
	throw new IllegalArgumentException(
	"Collection object cannot be null");
	ValidatingXMLStreamReader valXsr = new ValidatingXMLStreamReader();
	boolean[] retArray = new boolean[xml.length];

	for (int i = 0; i < xml.length; i++)
	{
	XMLStreamReader xsr = XMLInputFactory.newInstance().
	createXMLStreamReader(new FileInputStream(xml[i]));

	valXsr.init(xsr,
	false,
	type,
	XmlBeans.typeLoaderForClassLoader(ValidatingXMLStreamReader.class.getClassLoader()),
	null,
	errors);

	// Walk through the xml
	while (valXsr.hasNext())
	valXsr.next();

	retArray[i] = valXsr.isValid();
	}

	return retArray;
	}

	protected void checkDocIsValid(File file, SchemaType type) throws Exception {
	Collection errors = new ArrayList();
	boolean isValid = runValidator(file, type, errors);

	tools.xml.Utils.printXMLErrors(errors);
	Assert.assertTrue("File '" + file.getName() + "' is invalid.", isValid);
	}


	protected void checkDocIsInvalid(File file, SchemaType type) throws Exception {
	Collection errors = new ArrayList();

	boolean isValid = runValidator(file, type, errors);
	assertTrue("File '" + file.getName() + "' is valid, but was expecting invalid.",
	!isValid);
	}


	public boolean checkContent(String fragment,
	SchemaType type,
	boolean printErrors) throws Exception {
	XMLStreamReader xsr = XMLInputFactory.newInstance().
	createXMLStreamReader(new StringReader(fragment));

	XmlContentTestXSR cxsr = new XmlContentTestXSR(xsr);
	Collection errors = new ArrayList();

	ValidatingXMLStreamReader valXsr = new ValidatingXMLStreamReader();
	valXsr.init(cxsr,
	false,
	type,
	XmlBeans.typeLoaderForClassLoader(ValidatingXMLStreamReader.class.getClassLoader()),
	null,
	errors);

	// Walk through the xml
	while (valXsr.hasNext())
	valXsr.next();

	if (!valXsr.isValid())
	{
	if (printErrors)
	tools.xml.Utils.printXMLErrors(errors);
	return false;
	}
	return true;
	}


	private static File getCasesFile(String path)
	throws java.io.IOException
	{
	if (path.length()==0)
	throw new IOException("getCasesFile was called with path of len 0");
	return JarUtil.getResourceFromJarasFile(path);
	//return new File(casesRoot + path);
	}

	/////////////////////////////////////////////////////////////////////////
	// XmlStreamReader extension for content Validation
	// will not work for Global Attribute
	public class XmlContentTestXSR
	extends StreamReaderDelegate
	implements XMLStreamReader
	{
	private static final int TAGOPEN = 100;
	private static final int TAGCLOSE = 101;
	private static final int UNDEFINED = 99;
	private static final int ATTRIBUTE = 102;
	private static final int ENDCONTENT = 103;

	int state = -1;
	int depth = -1;
	boolean initialized = false;
	int attributeCount = -1;
	boolean hasAttributes = false;

	// Constructor Wrappers
	public XmlContentTestXSR(XMLStreamReader xsr)
	throws XMLStreamException
	{
	super(xsr);
	}


	public boolean hasNext()
	{
	if (state == UNDEFINED \|\| state == ENDCONTENT)
	return false;

	if (!initialized) // next() has not been called yet
	return true;



	return true;
	}

	public int next()
	throws XMLStreamException
	{
	int _next;
	if (!initialized)
	{
	// First time next() is called..
	// Scan for the first XMLEvent.START_ELEMENT
	_next = UNDEFINED;
	while ((super.hasNext()) && (_next != XMLEvent.START_ELEMENT))
	_next = super.next();

	if (_next != XMLEvent.START_ELEMENT)
	throw new XMLStreamException(
	"Could not find a start element");
	initialized = true;

	// Now move past the first tag
	state = TAGOPEN;
	depth = 1;

	if ((attributeCount = super.getAttributeCount()) > 0)
	{
	// The first element has attributes.. this is part of
	// the content. So the first event should XMLEvent.ATTRIBUTE
	_next = XMLEvent.ATTRIBUTE;
	}
	else
	{
	// return super.next();
	/*
	If content is <xml-fragment/> then we will have returned
	END_ELEMENT above, without ever generating a START_ELEMENT
	In this case probably we should detect this and return a
	END_DOCUMENT
	*/
	_next = super.next();
	if (_next == XMLEvent.END_ELEMENT)
	{
	_next = XMLEvent.END_DOCUMENT;
	state = ENDCONTENT;
	}
	}
	return _next;
	}

	_next = super.next();
	switch (_next)
	{
	case XMLEvent.START_ELEMENT:
	state = TAGOPEN;
	depth++;
	break;

	case XMLEvent.END_ELEMENT:
	--depth;
	if (depth < 0 && state == TAGOPEN)
	{
	throw new XMLStreamException(
	"Illegal XML Stream state");
	}
	else if (depth == 0 && state == TAGOPEN)
	{
	state = ENDCONTENT;
	// at this point we will return ENDDOCUMENT
	_next = XMLEvent.END_DOCUMENT;
	}
	break;
	}

	return _next;
	}

	}


	}