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.XmlError;
 import org.apache.xmlbeans.impl.validator.ValidatingXMLStreamReader;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.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.jupiter.api.Assertions.*;

 // 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
     void testDocWithNoSchema() throws Exception {
         checkDocIsInvalid(getCasesFile(casesLoc + "po.xml"), null);
     }

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

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

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

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

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

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

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


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

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


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

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

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

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

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

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

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

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

     @Test
     @Disabled
     public void testGlobalAttribute() throws Exception {
         String sXml = JarUtil.getResourceFromJar(casesLoc + "global-attr.xml");
         assertTrue(checkContent(sXml, null, true), "Global Attribute test failed:\n");
     }

     // Tests for increasing code-coverage metrics
     @Test
     void testValXsrReuse() throws Exception {
         Collection<XmlError> 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(2, ret.length, common + "\nReturn value has more than 2 elements");
         assertTrue(ret[0] && !ret[1], common + "\nExpected: true & false. Actual: " + ret[0] + " & " + ret[1]);
     }


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

     private boolean runValidator(File xml,
                                  SchemaType type,
                                  Collection<XmlError> 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<XmlError> 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<XmlError> errors = new ArrayList<>();
         boolean isValid = runValidator(file, type, errors);

         assertTrue(isValid, "File '" + file.getName() + "' is invalid.");
     }


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

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


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

         return valXsr.isValid();
     }


     private static File getCasesFile(String path)
         throws java.io.IOException {
         if (path.isEmpty()) {
             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
     private static 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.XmlError;
	import org.apache.xmlbeans.impl.validator.ValidatingXMLStreamReader;
	import org.junit.jupiter.api.Disabled;
	import org.junit.jupiter.api.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.jupiter.api.Assertions.*;

	// 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
	void testDocWithNoSchema() throws Exception {
	checkDocIsInvalid(getCasesFile(casesLoc + "po.xml"), null);
	}

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

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

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

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

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

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

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


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

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


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

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

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

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

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

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

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

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

	@Test
	@Disabled
	public void testGlobalAttribute() throws Exception {
	String sXml = JarUtil.getResourceFromJar(casesLoc + "global-attr.xml");
	assertTrue(checkContent(sXml, null, true), "Global Attribute test failed:\n");
	}

	// Tests for increasing code-coverage metrics
	@Test
	void testValXsrReuse() throws Exception {
	Collection<XmlError> 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(2, ret.length, common + "\nReturn value has more than 2 elements");
	assertTrue(ret[0] && !ret[1], common + "\nExpected: true & false. Actual: " + ret[0] + " & " + ret[1]);
	}


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

	private boolean runValidator(File xml,
	SchemaType type,
	Collection<XmlError> 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<XmlError> 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<XmlError> errors = new ArrayList<>();
	boolean isValid = runValidator(file, type, errors);

	assertTrue(isValid, "File '" + file.getName() + "' is invalid.");
	}


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

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


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

	return valXsr.isValid();
	}


	private static File getCasesFile(String path)
	throws java.io.IOException {
	if (path.isEmpty()) {
	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
	private static 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;
	}

	}


	}