/**
* 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.yoko.bindings.corba;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.util.ArrayList;
import java.util.List;
import javax.xml.namespace.QName;
import javax.xml.stream.XMLEventFactory;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLEventWriter;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.EndElement;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;
import junit.framework.TestCase;
import org.apache.cxf.Bus;
import org.apache.cxf.message.Message;
import org.apache.cxf.service.model.EndpointInfo;
import org.apache.cxf.service.model.ServiceInfo;
import org.apache.cxf.ws.addressing.EndpointReferenceType;
import org.apache.schemas.yoko.bindings.corba.Array;
import org.apache.schemas.yoko.bindings.corba.Enum;
import org.apache.schemas.yoko.bindings.corba.Enumerator;
import org.apache.schemas.yoko.bindings.corba.Fixed;
import org.apache.schemas.yoko.bindings.corba.MemberType;
import org.apache.schemas.yoko.bindings.corba.Sequence;
import org.apache.schemas.yoko.bindings.corba.Struct;
import org.apache.schemas.yoko.bindings.corba.TypeMappingType;
import org.apache.schemas.yoko.bindings.corba.Union;
import org.apache.yoko.wsdl.CorbaConstants;
import org.apache.yoko.bindings.corba.types.CorbaArrayHandler;
import org.apache.yoko.bindings.corba.types.CorbaEnumHandler;
import org.apache.yoko.bindings.corba.types.CorbaFixedHandler;
import org.apache.yoko.bindings.corba.types.CorbaObjectHandler;
import org.apache.yoko.bindings.corba.types.CorbaPrimitiveHandler;
import org.apache.yoko.bindings.corba.types.CorbaSequenceHandler;
import org.apache.yoko.bindings.corba.types.CorbaStructHandler;
import org.apache.yoko.bindings.corba.types.CorbaUnionHandler;
import org.apache.yoko.wsdl.CorbaTypeImpl;
import org.omg.CORBA.ORB;
import org.omg.CORBA.TCKind;
import org.omg.CORBA.TypeCode;
/**
* Holder for reading and writing stax methods.
*/
public class CorbaStaxObjectTest extends TestCase {
protected Bus bus;
protected static ORB orb;
protected EndpointReferenceType target;
protected Message inMessage;
protected EndpointInfo endpointInfo;
CorbaBindingFactory factory;
CorbaStaxObject staxObject;
private final static String staxTestNamespaceURI = "http://yoko.apache.org/StaxTest/idl_types";
private final static String staxTestPrefix = "corbatm";
public CorbaStaxObjectTest() {
super();
}
protected void setUp() throws Exception {
super.setUp();
java.util.Properties props = System.getProperties();
props.put("org.omg.CORBA.ORBClass", "org.apache.yoko.orb.CORBA.ORB");
props.put("org.omg.CORBA.ORBSingletonClass", "org.apache.yoko.orb.CORBA.ORBSingleton");
props.put("yoko.orb.id", "Yoko-Server-Binding");
orb = ORB.init(new String[0], props);
staxObject = new CorbaStaxObject(orb);
staxObject.setOrb(orb);
TestUtils testUtils = new TestUtils();
endpointInfo = testUtils.setupServiceInfo("http://yoko.apache.org/StaxTest",
"/wsdl/StaxTest.wsdl", "StaxTestCORBAService",
"StaxTestCORBAPort");
List<CorbaTypeMap> typeMaps;
typeMaps = new ArrayList<CorbaTypeMap>();
CorbaDestination destination = testUtils.getStaxTypesTestDestination();
ServiceInfo service = destination.getBindingInfo().getService();
List<TypeMappingType> corbaTypes = service.getDescription().getExtensors(TypeMappingType.class);
if (corbaTypes != null) {
CorbaUtils.createCorbaTypeMap(typeMaps, corbaTypes);
staxObject.setTypeMaps(typeMaps);
staxObject.setServiceInfo(service);
}
}
public void tearDown() throws Exception {
super.setUp();
if (orb != null) {
try {
orb.destroy();
} catch (Exception ex) {
// Do nothing. Throw an Exception?
}
}
}
public void testReadWriteStaxPrimitive() {
CorbaPrimitiveHandler obj = new CorbaPrimitiveHandler(new QName("BooleanType"),
CorbaConstants.NT_CORBA_BOOLEAN,
orb.get_primitive_tc(TCKind.tk_boolean),
null);
obj.setValueFromData("false");
XMLInputFactory inputFactory = XMLInputFactory.newInstance();
XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
outputFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
XMLEventWriter evtWriter = null;
try {
evtWriter = outputFactory.createXMLEventWriter(outStream);
} catch (XMLStreamException ex) {
}
assertNotNull(evtWriter);
try {
XMLEventFactory factory = XMLEventFactory.newInstance();
StartElement startEl = factory.createStartElement(obj.getName(), null, null);
evtWriter.add(startEl);
staxObject.writeObjectToStax(obj, evtWriter, factory);
EndElement endEl = factory.createEndElement(obj.getName(), null);
evtWriter.add(endEl);
evtWriter.flush();
} catch (XMLStreamException ex) {
}
ByteArrayInputStream inStream = new ByteArrayInputStream(outStream.toByteArray());
XMLEventReader evtReader = null;
try {
evtReader = inputFactory.createXMLEventReader(inStream);
// read the first tag which should be a start document
XMLEvent evt = evtReader.nextEvent();
assertTrue(evt.isStartDocument());
} catch (XMLStreamException ex) {
}
assertNotNull(evtReader);
CorbaObjectHandler result = (CorbaObjectHandler) staxObject.readObjectFromStax(evtReader,
obj.getIdlType());
assertNotNull(result);
assertTrue(result instanceof CorbaPrimitiveHandler);
CorbaPrimitiveHandler resultObj = (CorbaPrimitiveHandler)result;
assertTrue(resultObj.getName().equals(obj.getName()));
assertTrue(resultObj.getIdlType().equals(obj.getIdlType()));
assertTrue(resultObj.getTypeCode().equal(obj.getTypeCode()));
assertTrue(resultObj.getDataFromValue().equals(obj.getDataFromValue()));
}
public void testReadWriteStaxArray() {
QName objName = new QName("object");
QName objIdlType = new QName(staxTestNamespaceURI, "TestArray", staxTestPrefix);
TypeCode objTypeCode = CorbaUtils.getTypeCode(orb, objIdlType, staxObject.getTypeMaps());
CorbaTypeImpl type = CorbaUtils.getCorbaType(objIdlType, staxObject.getTypeMaps());
assertTrue(type instanceof Array);
Array arrayType = (Array)type;
CorbaArrayHandler obj = new CorbaArrayHandler(objName, objIdlType, objTypeCode, arrayType);
assertNotNull(obj);
List<CorbaObjectHandler> objElements = new ArrayList<CorbaObjectHandler>();
int arrayData[] = { 2, 4, 6, 8, 10 };
for (int i = 0 ; i < arrayData.length; ++i) {
QName elName = new QName("item");
QName elIdlType = CorbaConstants.NT_CORBA_LONG;
TypeCode elTC = orb.get_primitive_tc(TCKind.tk_long);
CorbaPrimitiveHandler el = new CorbaPrimitiveHandler(elName, elIdlType, elTC, null);
el.setValue(Integer.valueOf(arrayData[i]));
obj.addElement(el);
objElements.add(el);
}
XMLInputFactory inputFactory = XMLInputFactory.newInstance();
XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
outputFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
XMLEventWriter evtWriter = null;
try {
evtWriter = outputFactory.createXMLEventWriter(outStream);
} catch (XMLStreamException ex) {
}
assertNotNull(evtWriter);
try {
XMLEventFactory factory = XMLEventFactory.newInstance();
StartElement startEl = factory.createStartElement(obj.getName(), null, null);
evtWriter.add(startEl);
staxObject.writeObjectToStax(obj, evtWriter, factory);
EndElement endEl = factory.createEndElement(obj.getName(), null);
evtWriter.add(endEl);
evtWriter.flush();
} catch (XMLStreamException ex) {
}
ByteArrayInputStream inStream = new ByteArrayInputStream(outStream.toByteArray());
XMLEventReader evtReader = null;
try {
evtReader = inputFactory.createXMLEventReader(inStream);
// read the first tag which should be a start document
XMLEvent evt = evtReader.nextEvent();
assertTrue(evt.isStartDocument());
} catch (XMLStreamException ex) {
}
assertNotNull(evtReader);
CorbaObjectHandler result = staxObject.readObjectFromStax(evtReader,
obj.getIdlType());
assertNotNull(result);
assertTrue(result instanceof CorbaArrayHandler);
CorbaArrayHandler resultObj = (CorbaArrayHandler)result;
assertTrue(resultObj.getName().equals(obj.getName()));
assertTrue(resultObj.getIdlType().equals(obj.getIdlType()));
assertTrue(resultObj.getTypeCode().equal(obj.getTypeCode()));
List<CorbaObjectHandler> resultElements = resultObj.getElements();
for (int i = 0; i < resultElements.size(); ++i) {
assertTrue(resultElements.get(i) instanceof CorbaPrimitiveHandler);
CorbaPrimitiveHandler resultEl = (CorbaPrimitiveHandler)resultElements.get(i);
CorbaPrimitiveHandler objEl = (CorbaPrimitiveHandler)objElements.get(i);
assertTrue(resultEl.getDataFromValue().equals(objEl.getDataFromValue()));
}
}
public void testReadWriteStaxEnum() {
QName objName = new QName("object");
QName objIdlType = new QName(staxTestNamespaceURI, "TestEnum", staxTestPrefix);
CorbaTypeImpl type = CorbaUtils.getCorbaType(objIdlType, staxObject.getTypeMaps());
assertTrue(type instanceof Enum);
Enum enumType = (Enum)type;
List<Enumerator> enumerators = enumType.getEnumerator();
String[] enums = new String[enumerators.size()];
for (int i = 0; i < enumerators.size(); ++i) {
Enumerator e = enumerators.get(i);
enums[i] = e.getValue();
}
TypeCode objTypeCode = CorbaUtils.getTypeCode(orb, objIdlType, staxObject.getTypeMaps());
CorbaEnumHandler obj = new CorbaEnumHandler(objName, objIdlType, objTypeCode, enumType);
assertNotNull(obj);
obj.setValue(enums[1]);
XMLInputFactory inputFactory = XMLInputFactory.newInstance();
XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
outputFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
XMLEventWriter evtWriter = null;
try {
evtWriter = outputFactory.createXMLEventWriter(outStream);
} catch (XMLStreamException ex) {
}
assertNotNull(evtWriter);
try {
XMLEventFactory factory = XMLEventFactory.newInstance();
staxObject.writeObjectToStax(obj, evtWriter, factory);
evtWriter.flush();
} catch (XMLStreamException ex) {
}
ByteArrayInputStream inStream = new ByteArrayInputStream(outStream.toByteArray());
XMLEventReader evtReader = null;
try {
evtReader = inputFactory.createXMLEventReader(inStream);
// read the first tag which should be a start document
XMLEvent evt = evtReader.nextEvent();
assertTrue(evt.isStartDocument());
} catch (XMLStreamException ex) {
}
assertNotNull(evtReader);
CorbaObjectHandler resultObj = staxObject.readObjectFromStax(evtReader,
obj.getIdlType());
assertNotNull(resultObj);
assertTrue(resultObj instanceof CorbaEnumHandler);
CorbaEnumHandler result = (CorbaEnumHandler)resultObj;
Object resultValueObj = result.getValue();
assertTrue(resultValueObj instanceof String);
String resultValue = (String)resultValueObj;
assertTrue(resultValue.equals(enums[1]));
}
public void testReadWriteStaxFixed() {
QName objName = new QName("object");
QName objIdlType = new QName(staxTestNamespaceURI, "TestFixed", staxTestPrefix);
CorbaTypeImpl type = CorbaUtils.getCorbaType(objIdlType, staxObject.getTypeMaps());
assertTrue(type instanceof Fixed);
Fixed fixedType = (Fixed)type;
TypeCode objTypeCode = CorbaUtils.getTypeCode(orb, objIdlType, staxObject.getTypeMaps());
CorbaFixedHandler obj = new CorbaFixedHandler(objName, objIdlType, objTypeCode, fixedType);
assertNotNull(obj);
java.math.BigDecimal fixedValue = new java.math.BigDecimal("12345.67");
obj.setValue(fixedValue);
XMLInputFactory inputFactory = XMLInputFactory.newInstance();
XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
outputFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
XMLEventWriter evtWriter = null;
try {
evtWriter = outputFactory.createXMLEventWriter(outStream);
} catch (XMLStreamException ex) {
}
assertNotNull(evtWriter);
try {
XMLEventFactory factory = XMLEventFactory.newInstance();
staxObject.writeObjectToStax(obj, evtWriter, factory);
evtWriter.flush();
} catch (XMLStreamException ex) {
}
ByteArrayInputStream inStream = new ByteArrayInputStream(outStream.toByteArray());
XMLEventReader evtReader = null;
try {
evtReader = inputFactory.createXMLEventReader(inStream);
// read the first tag which should be a start document
XMLEvent evt = evtReader.nextEvent();
assertTrue(evt.isStartDocument());
} catch (XMLStreamException ex) {
}
assertNotNull(evtReader);
CorbaObjectHandler resultObj = staxObject.readObjectFromStax(evtReader,
obj.getIdlType());
assertNotNull(resultObj);
assertTrue(resultObj instanceof CorbaFixedHandler);
CorbaFixedHandler result = (CorbaFixedHandler)resultObj;
Object resultValueObj = result.getValue();
assertTrue(resultValueObj instanceof java.math.BigDecimal);
java.math.BigDecimal resultValue = (java.math.BigDecimal)resultValueObj;
assertTrue(resultValue.toString().equals(fixedValue.toString()));
}
public void testReadWriteStaxSequence() {
QName objName = new QName("TestSequence");
QName objIdlType = new QName(staxTestNamespaceURI, "TestSequence", staxTestPrefix);
TypeCode objTypeCode = CorbaUtils.getTypeCode(orb, objIdlType, staxObject.getTypeMaps());
CorbaTypeImpl type = CorbaUtils.getCorbaType(objIdlType, staxObject.getTypeMaps());
assertTrue(type instanceof Sequence);
Sequence seqType = (Sequence)type;
CorbaSequenceHandler obj = new CorbaSequenceHandler(objName, objIdlType, objTypeCode, seqType);
assertNotNull(obj);
List<CorbaObjectHandler> objElements = new ArrayList<CorbaObjectHandler>();
short seqData[] = { 1, 3, 5, 7 };
for (int i = 0 ; i < seqData.length; ++i) {
QName elName = new QName("item");
QName elIdlType = CorbaConstants.NT_CORBA_SHORT;
TypeCode elTC = orb.get_primitive_tc(TCKind.tk_short);
CorbaPrimitiveHandler el = new CorbaPrimitiveHandler(elName, elIdlType, elTC, null);
el.setValue(Short.valueOf(seqData[i]));
obj.addElement(el);
objElements.add(el);
}
XMLInputFactory inputFactory = XMLInputFactory.newInstance();
XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
outputFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
XMLEventWriter evtWriter = null;
try {
evtWriter = outputFactory.createXMLEventWriter(outStream);
} catch (XMLStreamException ex) {
}
assertNotNull(evtWriter);
try {
XMLEventFactory factory = XMLEventFactory.newInstance();
staxObject.writeObjectToStax(obj, evtWriter, factory);
evtWriter.flush();
} catch (XMLStreamException ex) {
}
ByteArrayInputStream inStream = new ByteArrayInputStream(outStream.toByteArray());
XMLEventReader evtReader = null;
try {
evtReader = inputFactory.createXMLEventReader(inStream);
// read the first tag which should be a start document
XMLEvent evt = evtReader.nextEvent();
assertTrue(evt.isStartDocument());
} catch (XMLStreamException ex) {
}
assertNotNull(evtReader);
CorbaObjectHandler result = staxObject.readObjectFromStax(evtReader,
obj.getIdlType());
assertNotNull(result);
assertTrue(result instanceof CorbaSequenceHandler);
CorbaSequenceHandler resultObj = (CorbaSequenceHandler)result;
assertTrue(resultObj.getName().equals(obj.getName()));
assertTrue(resultObj.getIdlType().equals(obj.getIdlType()));
assertTrue(resultObj.getTypeCode().equal(obj.getTypeCode()));
List<CorbaObjectHandler> resultElements = resultObj.getElements();
for (int i = 0; i < resultElements.size(); ++i) {
assertTrue(resultElements.get(i) instanceof CorbaPrimitiveHandler);
CorbaPrimitiveHandler resultEl = (CorbaPrimitiveHandler)resultElements.get(i);
CorbaPrimitiveHandler objEl = (CorbaPrimitiveHandler)objElements.get(i);
assertTrue(resultEl.getDataFromValue().equals(objEl.getDataFromValue()));
}
}
public void testReadWriteStaxStruct() {
QName objName = new QName("object");
QName objIdlType = new QName(staxTestNamespaceURI, "TestStruct", staxTestPrefix);
CorbaTypeImpl type = CorbaUtils.getCorbaType(objIdlType, staxObject.getTypeMaps());
assertTrue(type instanceof Struct);
Struct structType = (Struct)type;
TypeCode objTypeCode = CorbaUtils.getTypeCode(orb, objIdlType, staxObject.getTypeMaps());
CorbaStructHandler obj = new CorbaStructHandler(objName, objIdlType, objTypeCode, structType);
assertNotNull(obj);
List<MemberType> structMembers = structType.getMember();
// For this test, we know what each of the members are. Create the correct handler and assign
// each member a value
MemberType m1 = structMembers.get(0);
TypeCode m1TypeCode = CorbaUtils.getTypeCode(orb, m1.getIdltype(), staxObject.getTypeMaps());
CorbaPrimitiveHandler member1 = new CorbaPrimitiveHandler(new QName(m1.getName()),
m1.getIdltype(),
m1TypeCode,
null);
Boolean member1Value = new Boolean(false);
member1.setValue(member1Value);
obj.addMember(member1);
MemberType m2 = structMembers.get(1);
TypeCode m2TypeCode = CorbaUtils.getTypeCode(orb, m2.getIdltype(), staxObject.getTypeMaps());
CorbaPrimitiveHandler member2 = new CorbaPrimitiveHandler(new QName(m2.getName()),
m2.getIdltype(),
m2TypeCode,
null);
String member2Value = "Member 2 string";
member2.setValue(member2Value);
obj.addMember(member2);
MemberType m3 = structMembers.get(2);
TypeCode m3TypeCode = CorbaUtils.getTypeCode(orb, m3.getIdltype(), staxObject.getTypeMaps());
CorbaPrimitiveHandler member3 = new CorbaPrimitiveHandler(new QName(m3.getName()),
m3.getIdltype(),
m3TypeCode,
null);
Float member3Value = new Float(12345.678);
member3.setValue(member3Value);
obj.addMember(member3);
XMLInputFactory inputFactory = XMLInputFactory.newInstance();
XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
outputFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
XMLEventWriter evtWriter = null;
try {
evtWriter = outputFactory.createXMLEventWriter(outStream);
} catch (XMLStreamException ex) {
}
assertNotNull(evtWriter);
try {
XMLEventFactory factory = XMLEventFactory.newInstance();
staxObject.writeObjectToStax(obj, evtWriter, factory);
evtWriter.flush();
} catch (XMLStreamException ex) {
}
ByteArrayInputStream inStream = new ByteArrayInputStream(outStream.toByteArray());
XMLEventReader evtReader = null;
try {
evtReader = inputFactory.createXMLEventReader(inStream);
// read the first tag which should be a start document
XMLEvent evt = evtReader.nextEvent();
assertTrue(evt.isStartDocument());
} catch (XMLStreamException ex) {
}
assertNotNull(evtReader);
CorbaObjectHandler resultObj = staxObject.readObjectFromStax(evtReader,
obj.getIdlType());
assertNotNull(resultObj);
assertTrue(resultObj instanceof CorbaStructHandler);
CorbaStructHandler result = (CorbaStructHandler)resultObj;
List<CorbaObjectHandler> resultMembers = result.getMembers();
assertTrue(resultMembers.size() == 3);
CorbaObjectHandler resultMember1Obj = resultMembers.get(0);
assertTrue(resultMember1Obj instanceof CorbaPrimitiveHandler);
CorbaPrimitiveHandler resultMember1 = (CorbaPrimitiveHandler)resultMember1Obj;
Object resultMember1ValueObj = resultMember1.getValue();
assertTrue(resultMember1ValueObj instanceof Boolean);
Boolean resultMember1Value = (Boolean)resultMember1ValueObj;
assertTrue(resultMember1Value.booleanValue() == member1Value.booleanValue());
CorbaObjectHandler resultMember2Obj = resultMembers.get(1);
assertTrue(resultMember2Obj instanceof CorbaPrimitiveHandler);
CorbaPrimitiveHandler resultMember2 = (CorbaPrimitiveHandler)resultMember2Obj;
Object resultMember2ValueObj = resultMember2.getValue();
assertTrue(resultMember2ValueObj instanceof String);
String resultMember2Value = (String)resultMember2ValueObj;
assertTrue(resultMember2Value.equals(member2Value));
CorbaObjectHandler resultMember3Obj = resultMembers.get(2);
assertTrue(resultMember3Obj instanceof CorbaPrimitiveHandler);
CorbaPrimitiveHandler resultMember3 = (CorbaPrimitiveHandler)resultMember3Obj;
Object resultMember3ValueObj = resultMember3.getValue();
assertTrue(resultMember3ValueObj instanceof Float);
Float resultMember3Value = (Float)resultMember3ValueObj;
assertTrue(resultMember3Value.floatValue() == member3Value.floatValue());
}
public void testReadWriteUnionStruct() {
QName objName = new QName("object");
QName objIdlType = new QName(staxTestNamespaceURI, "TestUnion", staxTestPrefix);
CorbaTypeImpl type = CorbaUtils.getCorbaType(objIdlType, staxObject.getTypeMaps());
assertTrue(type instanceof Union);
Union unionType = (Union)type;
TypeCode objTypeCode = CorbaUtils.getTypeCode(orb, objIdlType, staxObject.getTypeMaps());
CorbaUnionHandler obj = new CorbaUnionHandler(objName, objIdlType, objTypeCode, unionType);
assertNotNull(obj);
Character unionValue = new Character('u');
TypeCode unionValueTC = CorbaUtils.getTypeCode(orb, CorbaConstants.NT_CORBA_WCHAR,
staxObject.getTypeMaps());
CorbaPrimitiveHandler unionValueObj = new CorbaPrimitiveHandler(new QName("case12"),
CorbaConstants.NT_CORBA_WCHAR,
unionValueTC,
null);
unionValueObj.setValue(unionValue);
Short discriminatorValue = new Short((short)1);
TypeCode discriminatorTC = CorbaUtils.getTypeCode(orb, unionType.getDiscriminator(),
staxObject.getTypeMaps());
CorbaPrimitiveHandler discriminator = new CorbaPrimitiveHandler(new QName("discriminator"),
unionType.getDiscriminator(),
discriminatorTC,
null);
discriminator.setValue(discriminatorValue);
obj.setDiscriminator(discriminator);
obj.setValue("1", unionValueObj);
XMLInputFactory inputFactory = XMLInputFactory.newInstance();
XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
outputFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
XMLEventWriter evtWriter = null;
try {
evtWriter = outputFactory.createXMLEventWriter(outStream);
} catch (XMLStreamException ex) {
}
assertNotNull(evtWriter);
try {
XMLEventFactory factory = XMLEventFactory.newInstance();
staxObject.writeObjectToStax(obj, evtWriter, factory);
evtWriter.flush();
} catch (XMLStreamException ex) {
}
ByteArrayInputStream inStream = new ByteArrayInputStream(outStream.toByteArray());
XMLEventReader evtReader = null;
try {
evtReader = inputFactory.createXMLEventReader(inStream);
// read the first tag which should be a start document
XMLEvent evt = evtReader.nextEvent();
assertTrue(evt.isStartDocument());
} catch (XMLStreamException ex) {
}
assertNotNull(evtReader);
CorbaObjectHandler resultObj = staxObject.readObjectFromStax(evtReader,
obj.getIdlType());
assertNotNull(resultObj);
assertTrue(resultObj instanceof CorbaUnionHandler);
CorbaUnionHandler result = (CorbaUnionHandler)resultObj;
CorbaObjectHandler resultDiscriminatorObj = result.getDiscriminator();
assertTrue(resultDiscriminatorObj instanceof CorbaPrimitiveHandler);
CorbaPrimitiveHandler resultDiscriminator = (CorbaPrimitiveHandler)resultDiscriminatorObj;
Object resultDiscValueObj = resultDiscriminator.getValue();
assertTrue(resultDiscValueObj instanceof Short);
Short resultDiscValue = (Short)resultDiscValueObj;
assertTrue(resultDiscValue.shortValue() == discriminatorValue.shortValue());
CorbaObjectHandler resultValueObj = result.getValue();
assertTrue(resultValueObj instanceof CorbaPrimitiveHandler);
CorbaPrimitiveHandler resultValue = (CorbaPrimitiveHandler)resultValueObj;
Object unionResultValueObj = resultValue.getValue();
assertTrue(unionResultValueObj instanceof Character);
Character unionResultValue = (Character)unionResultValueObj;
assertTrue(unionResultValue.charValue() == unionValue.charValue());
}
}