| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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.apache.axis2.databinding.utils.reader; |
| |
| import org.apache.axiom.attachments.ByteArrayDataSource; |
| import org.apache.axiom.om.OMAbstractFactory; |
| import org.apache.axiom.om.OMAttribute; |
| import org.apache.axiom.om.OMElement; |
| import org.apache.axiom.om.OMFactory; |
| import org.apache.axiom.om.OMNamespace; |
| import org.apache.axiom.om.impl.serialize.StreamingOMSerializer; |
| import org.apache.axiom.om.util.Base64; |
| import org.apache.axiom.om.util.StAXUtils; |
| import org.apache.axis2.databinding.ADBBean; |
| import org.apache.axis2.databinding.ADBException; |
| import org.apache.axis2.databinding.utils.Constants; |
| import org.apache.axis2.databinding.utils.writer.MTOMAwareXMLStreamWriter; |
| import org.apache.axis2.util.StreamWrapper; |
| import org.custommonkey.xmlunit.XMLTestCase; |
| import org.w3c.dom.Document; |
| import org.xml.sax.SAXException; |
| |
| import javax.activation.DataHandler; |
| import javax.xml.namespace.QName; |
| import javax.xml.parsers.DocumentBuilder; |
| import javax.xml.parsers.DocumentBuilderFactory; |
| import javax.xml.parsers.ParserConfigurationException; |
| import javax.xml.stream.XMLStreamException; |
| import javax.xml.stream.XMLStreamReader; |
| import javax.xml.stream.XMLStreamWriter; |
| import java.io.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| public class ADBXMLStreamReaderTest extends XMLTestCase { |
| |
| private DocumentBuilder db; |
| |
| protected void setUp() throws Exception { |
| DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); |
| dbf.setNamespaceAware(true); |
| db = dbf.newDocumentBuilder(); |
| } |
| |
| /** complex array scenario */ |
| public void testComplexObjectArrayScenario() { |
| try { |
| String expectedXML = |
| "<ns1:TestComplexStringArrayScenario xmlns:ns1=\"http://testComplexStringArrayScenario.org\">" + |
| "<Foo>Some Text</Foo>" + |
| "<Dependent>" + |
| "<Name>FooTwo</Name>" + |
| "<Age>25</Age>" + |
| "<Sex>Male</Sex>" + |
| "</Dependent>" + |
| "<AdditionalDependent>" + |
| "<Name>FooTwo</Name>" + |
| "<Age>25</Age>" + |
| "<Sex>Male</Sex>" + |
| "</AdditionalDependent>" + |
| "<AdditionalDependent>" + |
| "<Name>FooTwo</Name>" + |
| "<Age>25</Age>" + |
| "<Sex>Male</Sex>" + |
| "</AdditionalDependent>" + |
| "<AdditionalDependent>" + |
| "<Name>FooTwo</Name>" + |
| "<Age>25</Age>" + |
| "<Sex>Male</Sex>" + |
| "</AdditionalDependent>" + |
| "<AdditionalDependent>" + |
| "<Name>FooTwo</Name>" + |
| "<Age>25</Age>" + |
| "<Sex>Male</Sex>" + |
| "</AdditionalDependent>" + |
| "<Bar>Some More Text</Bar><" + |
| "/ns1:TestComplexStringArrayScenario>"; |
| |
| ArrayList propertyList = new ArrayList(); |
| propertyList.add("Foo"); |
| propertyList.add("Some Text"); |
| propertyList.add(new QName("Dependent")); |
| DummyADBBean dummyBean = new DummyADBBean(); |
| propertyList.add(dummyBean); |
| |
| ADBBean[] adbBeans = new ADBBean[4]; |
| for (int i = 0; i < 4; i++) { |
| adbBeans[i] = new DummyADBBean(); |
| } |
| for (int i = 0; i < adbBeans.length; i++) { |
| propertyList.add(new QName("AdditionalDependent")); |
| propertyList.add(adbBeans[i]); |
| |
| } |
| |
| propertyList.add("Bar"); |
| propertyList.add("Some More Text"); |
| |
| XMLStreamReader pullParser = new ADBXMLStreamReaderImpl(new QName( |
| "http://testComplexStringArrayScenario.org", "TestComplexStringArrayScenario", |
| "ns1"), propertyList.toArray(), null); |
| String actualXML = getStringXML(pullParser); |
| |
| |
| assertXMLEqual(newDocument(expectedXML), newDocument(actualXML)); |
| } catch (ParserConfigurationException e) { |
| fail("Error has occurred " + e); |
| } catch (SAXException e) { |
| fail("Error has occurred " + e); |
| } catch (IOException e) { |
| fail("Error has occurred " + e); |
| } catch (Exception e) { |
| fail("Error has occurred " + e); |
| } |
| } |
| |
| /** complex array scenario with nulls in between */ |
| public void testComplexObjectArrayScenarioWithNulls() { |
| try { |
| String expectedXML = |
| "<ns1:TestComplexStringArrayScenario xmlns:ns1=\"http://testComplexStringArrayScenario.org\">" + |
| "<AdditionalDependent>" + |
| "<Name>FooTwo</Name>" + |
| "<Age>25</Age>" + |
| "<Sex>Male</Sex>" + |
| "</AdditionalDependent>" + |
| "<AdditionalDependent>" + |
| "<Name>FooTwo</Name>" + |
| "<Age>25</Age>" + |
| "<Sex>Male</Sex>" + |
| "</AdditionalDependent>" + |
| "<AdditionalDependent>" + |
| "<Name>FooTwo</Name>" + |
| "<Age>25</Age>" + |
| "<Sex>Male</Sex>" + |
| "</AdditionalDependent>" + |
| "<AdditionalDependent xsi:nil=\"true\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">" + |
| "</AdditionalDependent>" + |
| "<Bar>Some More Text</Bar><" + |
| "/ns1:TestComplexStringArrayScenario>"; |
| |
| ArrayList propertyList = new ArrayList(); |
| |
| ADBBean[] adbBeans = new ADBBean[4]; |
| for (int i = 0; i < 4; i++) { |
| adbBeans[i] = new DummyADBBean(); |
| } |
| |
| adbBeans[3] = null; |
| |
| for (int i = 0; i < adbBeans.length; i++) { |
| propertyList.add(new QName("AdditionalDependent")); |
| propertyList.add(adbBeans[i]); |
| |
| } |
| |
| propertyList.add("Bar"); |
| propertyList.add("Some More Text"); |
| |
| XMLStreamReader pullParser = new ADBXMLStreamReaderImpl(new QName( |
| "http://testComplexStringArrayScenario.org", "TestComplexStringArrayScenario", |
| "ns1"), propertyList.toArray(), null); |
| String actualXML = getStringXML(pullParser); |
| |
| assertXMLEqual(newDocument(expectedXML), newDocument(actualXML)); |
| } catch (ParserConfigurationException e) { |
| fail("Error has occurred " + e); |
| } catch (SAXException e) { |
| fail("Error has occurred " + e); |
| } catch (IOException e) { |
| fail("Error has occurred " + e); |
| } catch (Exception e) { |
| fail("Error has occurred " + e); |
| } |
| } |
| |
| /** Empty array */ |
| public void testComplexObjectArrayScenarioEmptyArray() { |
| try { |
| String expectedXML = |
| "<ns1:TestComplexStringArrayScenario xmlns:ns1=\"http://testComplexStringArrayScenario.org\">" + |
| "<Foo>Some Text</Foo>" + |
| "<Dependent>" + |
| "<Name>FooTwo</Name>" + |
| "<Age>25</Age>" + |
| "<Sex>Male</Sex>" + |
| "</Dependent>" + |
| "<Bar>Some More Text</Bar><" + |
| "/ns1:TestComplexStringArrayScenario>"; |
| |
| ArrayList propertyList = new ArrayList(); |
| propertyList.add("Foo"); |
| propertyList.add("Some Text"); |
| propertyList.add(new QName("Dependent")); |
| DummyADBBean dummyBean = new DummyADBBean(); |
| propertyList.add(dummyBean); |
| |
| String[] array = new String[] {}; |
| propertyList.add(new QName("AdditionalDependent")); |
| propertyList.add(array); |
| |
| propertyList.add("Bar"); |
| propertyList.add("Some More Text"); |
| |
| XMLStreamReader pullParser = new ADBXMLStreamReaderImpl( |
| new QName("http://testComplexStringArrayScenario.org", |
| "TestComplexStringArrayScenario", "ns1"), |
| propertyList.toArray(), |
| null); |
| String actualXML = getStringXML(pullParser); |
| assertXMLEqual(newDocument(expectedXML), newDocument(actualXML)); |
| |
| } catch (ParserConfigurationException e) { |
| fail("Error has occurred " + e); |
| } catch (SAXException e) { |
| fail("Error has occurred " + e); |
| } catch (IOException e) { |
| fail("Error has occurred " + e); |
| } catch (Exception e) { |
| fail("Error has occurred " + e); |
| } |
| } |
| |
| /** test a complex array list */ |
| public void testComplexArrayList() { |
| try { |
| |
| String exptectedXML = "<Person><Name>FooOne</Name><Organization>Apache</Organization>" + |
| "<Dependent><Name>FooTwo</Name><Age>25</Age><Sex>Male</Sex><Depemdent>" + |
| "<Name>FooTwo</Name><Age>25</Age><Sex>Male</Sex><Depemdent><Name>FooTwo</Name>" + |
| "<Age>25</Age><Sex>Male</Sex></Depemdent></Depemdent></Dependent>" + |
| "<test:Dependent xmlns:test=\"http://whatever.com\"><Name>FooTwo</Name><Age>25</Age>" + |
| "<Sex>Male</Sex><Depemdent><Name>FooTwo</Name><Age>25</Age><Sex>Male</Sex>" + |
| "</Depemdent></test:Dependent></Person>"; |
| |
| |
| ArrayList propertyList = new ArrayList(); |
| propertyList.add("Name"); |
| propertyList.add("FooOne"); |
| |
| propertyList.add("Organization"); |
| propertyList.add("Apache"); |
| |
| propertyList.add(new QName("Dependent")); |
| DummyADBBean dummyBean = new DummyADBBean(); |
| DummyADBBean nextdummyBean = dummyBean.addAnotherBean(); |
| nextdummyBean.addAnotherBean(); |
| propertyList.add(dummyBean); |
| |
| propertyList.add(new QName("http://whatever.com", "Dependent", "test")); |
| dummyBean = new DummyADBBean(); |
| dummyBean.addAnotherBean(); |
| propertyList.add(dummyBean); |
| |
| QName projectQName = new QName("Person"); |
| XMLStreamReader pullParser = |
| new ADBXMLStreamReaderImpl(projectQName, propertyList.toArray(), null); |
| |
| Document actualDom = newDocument(getStringXML(pullParser)); |
| Document expectedDocument = newDocument(exptectedXML); |
| assertXMLEqual(actualDom, expectedDocument); |
| } catch (ParserConfigurationException e) { |
| fail("Exception in parsing documents " + e); |
| } catch (SAXException e) { |
| fail("Exception in parsing documents " + e); |
| } catch (IOException e) { |
| fail("Exception in parsing documents " + e); |
| } catch (XMLStreamException e) { |
| fail("Exception in parsing documents " + e); |
| } |
| |
| } |
| |
| public static class DummyADBBean implements ADBBean { |
| ArrayList propertyList = new ArrayList(); |
| |
| public DummyADBBean() { |
| propertyList.add("Name"); |
| propertyList.add("FooTwo"); |
| propertyList.add("Age"); |
| propertyList.add("25"); |
| propertyList.add("Sex"); |
| propertyList.add("Male"); |
| } |
| |
| public DummyADBBean addAnotherBean() { |
| propertyList.add(new QName("Depemdent")); |
| DummyADBBean dummyBean = new DummyADBBean(); |
| propertyList.add(dummyBean); |
| return dummyBean; |
| } |
| |
| public XMLStreamReader getPullParser(QName adbBeanQName) { |
| return new ADBXMLStreamReaderImpl(adbBeanQName, propertyList.toArray(), null); |
| } |
| |
| public void serialize(final QName parentQName, |
| final OMFactory factory, |
| MTOMAwareXMLStreamWriter xmlWriter) |
| throws XMLStreamException, ADBException { |
| serialize(parentQName,factory,xmlWriter,false); |
| } |
| |
| public void serialize(final QName parentQName, |
| final OMFactory factory, |
| MTOMAwareXMLStreamWriter xmlWriter, |
| boolean serializeType) |
| throws XMLStreamException, ADBException { |
| throw new UnsupportedOperationException("Un implemented method"); |
| } |
| } |
| |
| public void testWithOMElements() throws XMLStreamException { |
| |
| String expectedXML = |
| "<OMElementTest><axis2:FirstOMElement xmlns:axis2=\"http://ws.apache.org/namespaces/axis2\">" + |
| "<axis2:SecondOMElement></axis2:SecondOMElement></axis2:FirstOMElement><Foo>Some Text</Foo>" + |
| "<Dependent><Name>FooTwo</Name><Age>25</Age><Sex>Male</Sex></Dependent>" + |
| "<axis2:SecondOMElement xmlns:axis2=\"http://ws.apache.org/namespaces/axis2\">" + |
| "</axis2:SecondOMElement></OMElementTest>"; |
| |
| OMFactory factory = OMAbstractFactory.getOMFactory(); |
| OMNamespace axis2Namespace = factory.createOMNamespace( |
| org.apache.axis2.Constants.AXIS2_NAMESPACE_URI, |
| org.apache.axis2.Constants.AXIS2_NAMESPACE_PREFIX); |
| OMElement firstElement = factory.createOMElement("FirstOMElement", axis2Namespace); |
| OMElement secondElement = |
| factory.createOMElement("SecondOMElement", axis2Namespace, firstElement); |
| |
| ArrayList propertyList = new ArrayList(); |
| |
| // add an OMElement |
| propertyList.add(firstElement.getQName()); |
| propertyList.add(firstElement); |
| |
| // add some more stuff |
| propertyList.add("Foo"); |
| propertyList.add("Some Text"); |
| propertyList.add(new QName("Dependent")); |
| DummyADBBean dummyBean = new DummyADBBean(); |
| propertyList.add(dummyBean); |
| |
| // lets add one more element |
| propertyList.add(secondElement.getQName()); |
| propertyList.add(secondElement); |
| |
| |
| XMLStreamReader pullParser = new ADBXMLStreamReaderImpl(new QName("OMElementTest"), |
| propertyList.toArray(), null); |
| String stringXML = getStringXML(pullParser); |
| try { |
| Document actualDom = newDocument(stringXML); |
| Document expectedDocument = newDocument(expectedXML); |
| assertXMLEqual(actualDom, expectedDocument); |
| } catch (ParserConfigurationException e) { |
| fail("Exception in parsing documents " + e); |
| } catch (SAXException e) { |
| fail("Exception in parsing documents " + e); |
| } catch (IOException e) { |
| fail("Exception in parsing documents " + e); |
| } |
| |
| } |
| |
| /** Test a completely null element */ |
| public void testNullableAttribute() { |
| try { |
| |
| /* |
| This is what I expect : |
| |
| */ |
| String exptectedXML = |
| "<Person xmlns=\"\"><Name xmlns=\"\">FooOne</Name><DependentOne xmlns=\"\" " + |
| "xsi:nil=\"true\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"/>" + |
| "</Person>"; |
| |
| ArrayList propertyList = new ArrayList(); |
| propertyList.add("Name"); |
| propertyList.add("FooOne"); |
| propertyList.add(new QName("DependentOne")); |
| propertyList.add(null); |
| |
| QName projectQName = new QName("Person"); |
| XMLStreamReader pullParser = |
| new ADBXMLStreamReaderImpl(projectQName, propertyList.toArray(), null); |
| |
| Document actualDom = newDocument(getStringXML(pullParser)); |
| Document expectedDocument = newDocument(exptectedXML); |
| assertXMLEqual(actualDom, expectedDocument); |
| } catch (ParserConfigurationException e) { |
| fail("Exception in parsing documents " + e); |
| } catch (SAXException e) { |
| fail("Exception in parsing documents " + e); |
| } catch (IOException e) { |
| fail("Exception in parsing documents " + e); |
| } catch (XMLStreamException e) { |
| fail("Exception in parsing documents " + e); |
| } |
| |
| } |
| |
| /** Test a simple array */ |
| public void testSimpleStringArrayScenario() { |
| try { |
| String expectedXML = |
| "<ns1:TestComplexStringArrayScenario xmlns:ns1=\"http://testComplexStringArrayScenario.org\">" + |
| "<StringInfo><array>Some Text 0</array>" + |
| "<array>Some Text 1</array>" + |
| "<array>Some Text 2</array>" + |
| "<array>Some Text 3</array></StringInfo>" + |
| "</ns1:TestComplexStringArrayScenario>"; |
| |
| ArrayList propertyList = new ArrayList(); |
| |
| String[] stringArray = new String[4]; |
| for (int i = 0; i < 4; i++) { |
| stringArray[i] = "Some Text " + i; |
| } |
| propertyList.add("StringInfo"); |
| propertyList.add(stringArray); |
| |
| XMLStreamReader pullParser = new ADBXMLStreamReaderImpl( |
| new QName("http://testComplexStringArrayScenario.org", |
| "TestComplexStringArrayScenario", "ns1"), |
| propertyList.toArray(), null); |
| String actualXML = getStringXML(pullParser); |
| |
| |
| assertXMLEqual(newDocument(expectedXML), newDocument(actualXML)); |
| } catch (ParserConfigurationException e) { |
| fail("Error has occurred " + e); |
| } catch (SAXException e) { |
| fail("Error has occurred " + e); |
| } catch (IOException e) { |
| fail("Error has occurred " + e); |
| } catch (XMLStreamException e) { |
| fail("Error has occurred " + e); |
| } |
| |
| |
| } |
| |
| /** Test a simple array with null's inbetween */ |
| public void testSimpleStringArrayScenarioWithNulls() { |
| try { |
| String expectedXML = |
| "<ns1:TestComplexStringArrayScenario xmlns:ns1=\"http://testComplexStringArrayScenario.org\">" + |
| "<StringInfo><array>Some Text 0</array>" + |
| "<array xsi:nil=\"true\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"/>" + |
| "<array>Some Text 2</array>" + |
| "<array>Some Text 3</array></StringInfo>" + |
| "</ns1:TestComplexStringArrayScenario>"; |
| |
| ArrayList propertyList = new ArrayList(); |
| |
| String[] stringArray = new String[4]; |
| for (int i = 0; i < 4; i++) { |
| stringArray[i] = "Some Text " + i; |
| } |
| stringArray[1] = null; |
| |
| propertyList.add("StringInfo"); |
| propertyList.add(stringArray); |
| |
| XMLStreamReader pullParser = new ADBXMLStreamReaderImpl( |
| new QName("http://testComplexStringArrayScenario.org", |
| "TestComplexStringArrayScenario", "ns1"), |
| propertyList.toArray(), null); |
| String actualXML = getStringXML(pullParser); |
| |
| |
| assertXMLEqual(newDocument(expectedXML), newDocument(actualXML)); |
| } catch (ParserConfigurationException e) { |
| fail("Error has occurred " + e); |
| } catch (SAXException e) { |
| fail("Error has occurred " + e); |
| } catch (IOException e) { |
| fail("Error has occurred " + e); |
| } catch (XMLStreamException e) { |
| fail("Error has occurred " + e); |
| } |
| |
| |
| } |
| |
| |
| /** test the mixed content */ |
| public void testComplexStringArrayScenarioWithMixedContent() { |
| try { |
| String expectedXML = |
| "<ns1:TestComplexStringArrayScenario xmlns:ns1=\"http://testComplexStringArrayScenario.org\">" + |
| "<Foo>Some Text</Foo>" + |
| "<Dependent>" + |
| "<Name>FooTwo</Name>" + |
| "<Age>25</Age>" + |
| "<Sex>Male</Sex>" + |
| "</Dependent>" + |
| "<StringInfo><array>Some Text 0</array>" + |
| "<array>Some Text 1</array>" + |
| "<array>Some Text 2</array>" + |
| "<array>Some Text 3</array></StringInfo>" + |
| "<Bar>Some More Text</Bar>" + |
| "</ns1:TestComplexStringArrayScenario>"; |
| |
| ArrayList propertyList = new ArrayList(); |
| propertyList.add("Foo"); |
| propertyList.add("Some Text"); |
| propertyList.add(new QName("Dependent")); |
| DummyADBBean dummyBean = new DummyADBBean(); |
| propertyList.add(dummyBean); |
| |
| String[] stringArray = new String[4]; |
| for (int i = 0; i < 4; i++) { |
| stringArray[i] = "Some Text " + i; |
| } |
| propertyList.add("StringInfo"); |
| propertyList.add(stringArray); |
| |
| propertyList.add("Bar"); |
| propertyList.add("Some More Text"); |
| |
| XMLStreamReader pullParser = new ADBXMLStreamReaderImpl( |
| new QName("http://testComplexStringArrayScenario.org", |
| "TestComplexStringArrayScenario", "ns1"), |
| propertyList.toArray(), |
| null); |
| String actualXML = getStringXML(pullParser); |
| |
| |
| assertXMLEqual(newDocument(expectedXML), newDocument(actualXML)); |
| } catch (ParserConfigurationException e) { |
| fail("Error has occurred " + e); |
| } catch (SAXException e) { |
| fail("Error has occurred " + e); |
| } catch (IOException e) { |
| fail("Error has occurred " + e); |
| } catch (Exception e) { |
| fail("Error has occurred " + e); |
| } |
| |
| |
| } |
| |
| /** Test a simple array with one element nil */ |
| public void testComplexStringArrayScenarioWithNull() { |
| try { |
| String expectedXML = "<ns1:TestComplexStringArrayScenario " + |
| "xmlns:ns1=\"http://testComplexStringArrayScenario.org\" " + |
| ">" + |
| "<StringInfo><array>Some Text 0</array>" + |
| "<array xsi:nil=\"true\" " + |
| "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"></array>" + |
| "<array>Some Text 2</array>" + |
| "<array>Some Text 3</array></StringInfo>" + |
| "</ns1:TestComplexStringArrayScenario>"; |
| |
| ArrayList propertyList = new ArrayList(); |
| |
| String[] stringArray = new String[4]; |
| for (int i = 0; i < 4; i++) { |
| if (i != 1) stringArray[i] = "Some Text " + i; |
| } |
| stringArray[1] = null; |
| |
| propertyList.add("StringInfo"); |
| propertyList.add(stringArray); |
| |
| XMLStreamReader pullParser = new ADBXMLStreamReaderImpl( |
| new QName("http://testComplexStringArrayScenario.org", |
| "TestComplexStringArrayScenario", "ns1"), |
| propertyList.toArray(), null); |
| String actualXML = getStringXML(pullParser); |
| |
| |
| assertXMLEqual(newDocument(expectedXML), newDocument(actualXML)); |
| } catch (ParserConfigurationException e) { |
| fail("Error has occurred " + e); |
| } catch (SAXException e) { |
| fail("Error has occurred " + e); |
| } catch (IOException e) { |
| fail("Error has occurred " + e); |
| } catch (XMLStreamException e) { |
| fail("Error has occurred " + e); |
| } |
| |
| |
| } |
| |
| /** |
| * Test multiple unqulified attributes |
| * |
| * @throws XMLStreamException |
| */ |
| public void testAttributes() throws XMLStreamException { |
| |
| String expectedXML = |
| "<emp:Employee xmlns:emp=\"http://ec.org/software\" Attr2=\"Value 2\" " + |
| "Attr3=\"Value 3\" Attr1=\"Value 1\" Attr5=\"Value 5\" Attr4=\"Value 4\"></emp:Employee>"; |
| |
| OMFactory factory = OMAbstractFactory.getOMFactory(); |
| QName elementQName = new QName("http://ec.org/software", "Employee", "emp"); |
| OMAttribute[] attribute = new OMAttribute[5]; |
| |
| for (int i = 0; i < 5; i++) { |
| attribute[i] = factory.createOMAttribute("Attr" + (i + 1), null, "Value " + (i + 1)); |
| } |
| |
| List omAttribList = new ArrayList(); |
| for (int i = 0; i < attribute.length; i++) { |
| omAttribList.add(Constants.OM_ATTRIBUTE_KEY); |
| omAttribList.add(attribute[i]); |
| } |
| |
| |
| String stringXML = getStringXML(new ADBXMLStreamReaderImpl(elementQName, |
| null, |
| omAttribList.toArray())); |
| try { |
| Document actualDom = newDocument(stringXML); |
| Document expectedDocument = newDocument(expectedXML); |
| assertXMLEqual(actualDom, expectedDocument); |
| } catch (ParserConfigurationException e) { |
| fail("Exception in parsing documents " + e); |
| } catch (SAXException e) { |
| fail("Exception in parsing documents " + e); |
| } catch (IOException e) { |
| fail("Exception in parsing documents " + e); |
| } |
| |
| |
| } |
| |
| /** A text only element */ |
| public void testElementText() { |
| |
| String expectedXML = "<ns1:testElementText xmlns:ns1=\"http://testElementText.org\">" + |
| "This is some Text for the element</ns1:testElementText>"; |
| try { |
| ArrayList properties = new ArrayList(); |
| properties.add(ADBXMLStreamReader.ELEMENT_TEXT); |
| properties.add("This is some Text for the element"); |
| |
| XMLStreamReader pullParser = new ADBXMLStreamReaderImpl( |
| new QName("http://testElementText.org", "testElementText", "ns1"), |
| properties.toArray(), null); |
| |
| String actualXML = getStringXML(pullParser); |
| |
| assertXMLEqual(newDocument(expectedXML), newDocument(actualXML)); |
| } catch (ParserConfigurationException e) { |
| fail("Error has occurred " + e); |
| } catch (SAXException e) { |
| fail("Error has occurred " + e); |
| } catch (IOException e) { |
| fail("Error has occurred " + e); |
| } catch (Exception e) { |
| e.printStackTrace(); |
| fail("Error has occurred " + e); |
| } |
| } |
| |
| /// todo Fails due to a bug in WSTX writer |
| // /** |
| // * Test multiple qualified attributes |
| // * @throws XMLStreamException |
| // */ |
| // public void testAttributesWithNamespaces() throws XMLStreamException { |
| // |
| // String expectedXML = "<emp:Employee xmlns:emp=\"http://ec.org/software\" " + |
| // "xmlns:attrNS=\"mailto:whoever@whatever.com\" attrNS:Attr2=\"Value 2\" " + |
| // "attrNS:Attr3=\"Value 3\" attrNS:Attr1=\"Value 1\"\n" + |
| // " attrNS:Attr5=\"Value 5\" attrNS:Attr4=\"Value 4\"></emp:Employee>"; |
| // |
| // OMFactory factory = OMAbstractFactory.getOMFactory(); |
| // QName elementQName = new QName("http://ec.org/software", "Employee", "emp"); |
| // OMNamespace attrNS = factory.createOMNamespace("mailto:whoever@whatever.com", "attrNS"); |
| // |
| // // add some attributes with namespaces |
| // OMAttribute[] attribute = new OMAttribute[5]; |
| // for (int i = 0; i < 5; i++) { |
| // attribute[i] = factory.createOMAttribute("Attr" + (i + 1), attrNS, "Value " + (i + 1)); |
| // } |
| // |
| // List omAttribList = new ArrayList(); |
| // for (int i = 0; i < attribute.length; i++) { |
| // omAttribList.add(Constants.OM_ATTRIBUTE_KEY); |
| // omAttribList.add(attribute[i]); |
| // } |
| // String stringXML = getStringXML(new ADBXMLStreamReaderImpl(elementQName, |
| // null, |
| // omAttribList.toArray())); |
| // try { |
| // Document actualDom = newDocument(stringXML); |
| // Document expectedDocument = newDocument(expectedXML); |
| // assertXMLEqual(actualDom, expectedDocument); |
| // } catch (ParserConfigurationException e) { |
| // fail("Exception in parsing documents " + e); |
| // } catch (SAXException e) { |
| // fail("Exception in parsing documents " + e); |
| // } catch (IOException e) { |
| // fail("Exception in parsing documents " + e); |
| // } |
| // } |
| |
| /** test for qualified attributes */ |
| public void testUnQualifiedAttributes() { |
| |
| String expectedXML = |
| "<ns1:testElementText xmlns:ns1=\"http://testElementText.org\" MyUnQualifiedAttribute=\"MyAttributeValue\">" + |
| "<ns2:QualifiedElement xmlns:ns2=\"http://testQElementText.org\">" + |
| "This is some Text for the element</ns2:QualifiedElement></ns1:testElementText>"; |
| try { |
| ArrayList properties = new ArrayList(); |
| properties.add(new QName("http://testQElementText.org", "QualifiedElement", "ns2")); |
| properties.add("This is some Text for the element"); |
| |
| String[] attributes = new String[2]; |
| attributes[0] = "MyUnQualifiedAttribute"; |
| attributes[1] = "MyAttributeValue"; |
| |
| |
| XMLStreamReader pullParser = new ADBXMLStreamReaderImpl( |
| new QName("http://testElementText.org", "testElementText", "ns1"), |
| properties.toArray(), |
| attributes); |
| |
| String actualXML = getStringXML(pullParser); |
| |
| assertXMLEqual(newDocument(expectedXML), newDocument(actualXML)); |
| } catch (ParserConfigurationException e) { |
| fail("Error has occurred " + e); |
| } catch (SAXException e) { |
| fail("Error has occurred " + e); |
| } catch (IOException e) { |
| fail("Error has occurred " + e); |
| } catch (Exception e) { |
| fail("Error has occurred " + e); |
| } |
| } |
| |
| /** test for base64 */ |
| public void testBase64EncodedText() { |
| |
| String textTobeSent = "33344MthwrrewrIOTEN)(&**^E(W)EW"; |
| |
| String expectedXML = "<ns1:testElementText xmlns:ns1=\"http://testElementText.org\">" + |
| "<ns2:QualifiedElement xmlns:ns2=\"http://testQElementText.org\">" + |
| Base64.encode(textTobeSent.getBytes()) + |
| "</ns2:QualifiedElement></ns1:testElementText>"; |
| try { |
| ArrayList properties = new ArrayList(); |
| properties.add(new QName("http://testQElementText.org", "QualifiedElement", "ns2")); |
| properties.add(new DataHandler(new ByteArrayDataSource(textTobeSent.getBytes()))); |
| |
| XMLStreamReader pullParser = new ADBXMLStreamReaderImpl( |
| new QName("http://testElementText.org", "testElementText", "ns1"), |
| properties.toArray(), |
| null); |
| |
| String actualXML = getStringXML(pullParser); |
| |
| assertXMLEqual(newDocument(expectedXML), newDocument(actualXML)); |
| } catch (ParserConfigurationException e) { |
| fail("Error has occurred " + e); |
| } catch (SAXException e) { |
| fail("Error has occurred " + e); |
| } catch (IOException e) { |
| fail("Error has occurred " + e); |
| } catch (Exception e) { |
| fail("Error has occurred " + e); |
| } |
| } |
| |
| /** test the qualified elements A qulified element has been associated with a namespace */ |
| public void testQualifiedElement() { |
| |
| String expectedXML = "<ns1:testElementText xmlns:ns1=\"http://testElementText.org\">" + |
| "<ns2:QualifiedElement xmlns:ns2=\"http://testQElementText.org\">" + |
| "This is some Text for the element</ns2:QualifiedElement></ns1:testElementText>"; |
| try { |
| ArrayList properties = new ArrayList(); |
| properties.add(new QName("http://testQElementText.org", "QualifiedElement", "ns2")); |
| properties.add("This is some Text for the element"); |
| |
| XMLStreamReader pullParser = new ADBXMLStreamReaderImpl( |
| new QName("http://testElementText.org", "testElementText", "ns1"), |
| properties.toArray(), |
| null); |
| |
| String actualXML = getStringXML(pullParser); |
| assertXMLEqual(newDocument(expectedXML), newDocument(actualXML)); |
| } catch (ParserConfigurationException e) { |
| fail("Error has occurred " + e); |
| } catch (SAXException e) { |
| fail("Error has occurred " + e); |
| } catch (IOException e) { |
| fail("Error has occurred " + e); |
| } catch (Exception e) { |
| fail("Error has occurred " + e); |
| } |
| } |
| |
| /** |
| * Util method to convert the pullstream to a string |
| * |
| * @param reader |
| * @return |
| */ |
| private String getStringXML(XMLStreamReader reader) throws XMLStreamException { |
| //the returned pullparser starts at an Element rather than the start |
| //document event. This is somewhat disturbing but since an ADBBean |
| //denotes an XMLFragment, it is justifiable to keep the current event |
| //at the Start-element rather than the start document |
| //What it boils down to is that we need to wrap the reader in a |
| //stream wrapper to get a fake start-document event |
| |
| StreamingOMSerializer ser = new StreamingOMSerializer(); |
| ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); |
| XMLStreamWriter writer = StAXUtils.createXMLStreamWriter(byteArrayOutputStream); |
| ser.serialize( |
| new StreamWrapper(reader), |
| writer); |
| writer.flush(); |
| return byteArrayOutputStream.toString(); |
| } |
| |
| // /** |
| // * Util method to convert the pullstream to a string |
| // * @param reader |
| // * @return |
| // */ |
| // private String getStringXML(XMLStreamReader reader) { |
| // //the returned pullparser starts at an Element rather than the start |
| // //document event. This is somewhat disturbing but since an ADBBean |
| // //denotes an XMLFragment, it is justifiable to keep the current event |
| // //at the Start-element rather than the start document |
| // //What it boils down to is that we need to wrap the reader in a |
| // //stream wrapper to get a fake start-document event |
| // StAXOMBuilder stAXOMBuilder = new StAXOMBuilder( |
| // new StreamWrapper(reader)); |
| // //stAXOMBuilder.setDoDebug(true); |
| // OMElement omelement = stAXOMBuilder.getDocumentElement(); |
| // return omelement.toString(); |
| // } |
| |
| /** |
| * Creates a DOM document from the string |
| * |
| * @param xml |
| * @return |
| * @throws ParserConfigurationException |
| * @throws SAXException |
| * @throws IOException |
| */ |
| public Document newDocument(String xml) |
| throws ParserConfigurationException, SAXException, IOException { |
| return db.parse(new ByteArrayInputStream(xml.getBytes())); |
| } |
| } |
