|
|
Apache CXF example source code file (AbstractTypeTestClient3.java)
This example Apache CXF source code file (AbstractTypeTestClient3.java) is included in the DevDaily.com
"Java Source Code
Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.
The Apache CXF AbstractTypeTestClient3.java source code
/**
* 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.cxf.systest.type_test;
import java.io.Serializable;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.xml.namespace.QName;
import javax.xml.soap.Name;
import javax.xml.soap.SOAPElement;
import javax.xml.soap.SOAPFactory;
import javax.xml.ws.Holder;
import org.w3c.dom.Element;
import org.apache.type_test.types1.DerivedChoiceBaseArray;
import org.apache.type_test.types1.DerivedChoiceBaseChoice;
import org.apache.type_test.types1.DerivedChoiceBaseStruct;
import org.apache.type_test.types1.DerivedEmptyBaseEmptyAll;
import org.apache.type_test.types1.DerivedEmptyBaseEmptyChoice;
import org.apache.type_test.types1.DerivedNoContent;
import org.apache.type_test.types1.DerivedStructBaseChoice;
import org.apache.type_test.types1.DerivedStructBaseEmpty;
import org.apache.type_test.types1.DerivedStructBaseStruct;
import org.apache.type_test.types1.RestrictedChoiceBaseChoice;
import org.apache.type_test.types1.SimpleChoice;
import org.apache.type_test.types1.SimpleStruct;
import org.apache.type_test.types1.UnboundedArray;
import org.apache.type_test.types2.ChoiceOfChoice;
import org.apache.type_test.types2.ChoiceOfSeq;
import org.apache.type_test.types2.ChoiceWithAnyAttribute;
import org.apache.type_test.types2.ChoiceWithBinary;
import org.apache.type_test.types2.ChoiceWithGroupChoice;
import org.apache.type_test.types2.ChoiceWithGroupSeq;
import org.apache.type_test.types2.ChoiceWithGroups;
import org.apache.type_test.types2.ComplexTypeWithAttributeGroup;
import org.apache.type_test.types2.ComplexTypeWithAttributeGroup1;
import org.apache.type_test.types2.ComplexTypeWithAttributes;
import org.apache.type_test.types2.ExtBase64Binary;
import org.apache.type_test.types2.GroupDirectlyInComplexType;
import org.apache.type_test.types2.IDTypeAttribute;
import org.apache.type_test.types2.MultipleOccursSequenceInSequence;
import org.apache.type_test.types2.SequenceWithGroupChoice;
import org.apache.type_test.types2.SequenceWithGroupSeq;
import org.apache.type_test.types2.SequenceWithGroups;
import org.apache.type_test.types2.SequenceWithOccuringGroup;
import org.apache.type_test.types2.StructWithAny;
import org.apache.type_test.types2.StructWithAnyArray;
import org.apache.type_test.types2.StructWithAnyAttribute;
import org.apache.type_test.types2.StructWithBinary;
import org.apache.type_test.types3.OccuringChoice;
import org.apache.type_test.types3.OccuringChoice1;
import org.apache.type_test.types3.OccuringChoice2;
import org.apache.type_test.types3.OccuringStruct;
import org.apache.type_test.types3.OccuringStruct1;
import org.apache.type_test.types3.OccuringStruct2;
import org.junit.Ignore;
import org.junit.Test;
public abstract class AbstractTypeTestClient3 extends AbstractTypeTestClient2 {
protected boolean equals(ChoiceOfChoice x, ChoiceOfChoice y) {
if (x.getVarInt() != null && y.getVarInt() != null) {
return x.getVarInt().equals(y.getVarInt());
}
if (x.getVarFloat() != null && y.getVarFloat() != null) {
return x.getVarFloat().equals(y.getVarFloat());
}
if (x.getVarOtherInt() != null && y.getVarOtherInt() != null) {
return x.getVarOtherInt().equals(y.getVarOtherInt());
}
if (x.getVarString() != null && y.getVarString() != null) {
return x.getVarString().equals(y.getVarString());
}
return false;
}
@Test
public void testChoiceOfChoice() throws Exception {
if (!shouldRunTest("ChoiceOfChoice")) {
return;
}
ChoiceOfChoice x = new ChoiceOfChoice();
ChoiceOfChoice yOrig = new ChoiceOfChoice();
x.setVarFloat(3.14f);
yOrig.setVarString("y456");
Holder<ChoiceOfChoice> y = new Holder(yOrig);
Holder<ChoiceOfChoice> z = new Holder();
ChoiceOfChoice ret;
if (testDocLiteral) {
ret = docClient.testChoiceOfChoice(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testChoiceOfChoice(x, y, z);
} else {
ret = rpcClient.testChoiceOfChoice(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testChoiceOfChoice(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testChoiceOfChoice(): Incorrect value for out param",
equals(yOrig, z.value));
assertTrue("testChoiceOfChoice(): Incorrect return value", equals(x, ret));
}
}
protected boolean equals(ChoiceOfSeq x, ChoiceOfSeq y) {
if (x.getVarFloat() != null && x.getVarInt() != null
&& y.getVarFloat() != null && y.getVarInt() != null) {
return x.getVarInt().equals(y.getVarInt())
&& x.getVarFloat().compareTo(y.getVarFloat()) == 0;
}
if (x.getVarOtherInt() != null && y.getVarOtherInt() != null
&& x.getVarString() != null && y.getVarString() != null) {
return x.getVarOtherInt().equals(y.getVarOtherInt())
&& x.getVarString().equals(y.getVarString());
}
return false;
}
@Test
public void testChoiceOfSeq() throws Exception {
if (!shouldRunTest("ChoiceOfSeq")) {
return;
}
ChoiceOfSeq x = new ChoiceOfSeq();
x.setVarInt(123);
x.setVarFloat(3.14f);
ChoiceOfSeq yOrig = new ChoiceOfSeq();
yOrig.setVarOtherInt(456);
yOrig.setVarString("y456");
Holder<ChoiceOfSeq> y = new Holder(yOrig);
Holder<ChoiceOfSeq> z = new Holder();
ChoiceOfSeq ret;
if (testDocLiteral) {
ret = docClient.testChoiceOfSeq(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testChoiceOfSeq(x, y, z);
} else {
ret = rpcClient.testChoiceOfSeq(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testChoiceOfSeq(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testChoiceOfSeq(): Incorrect value for out param",
equals(yOrig, z.value));
assertTrue("testChoiceOfSeq(): Incorrect return value", equals(x, ret));
}
}
protected boolean equals(DerivedStructBaseStruct x, DerivedStructBaseStruct y) {
return equals((SimpleStruct)x, (SimpleStruct)y)
&& (x.getVarFloatExt() == y.getVarFloatExt())
&& (x.getVarStringExt().equals(y.getVarStringExt()))
&& (x.getAttrString1().equals(y.getAttrString1()))
&& (x.getAttrString2().equals(y.getAttrString2()));
}
@Test
public void testDerivedStructBaseStruct() throws Exception {
if (!shouldRunTest("DerivedStructBaseStruct")) {
return;
}
DerivedStructBaseStruct x = new DerivedStructBaseStruct();
//Base
x.setVarFloat(3.14f);
x.setVarInt(new BigInteger("42"));
x.setVarString("BaseStruct-x");
x.setVarAttrString("BaseStructAttr-x");
//Derived
x.setVarFloatExt(-3.14f);
x.setVarStringExt("DerivedStruct-x");
x.setAttrString1("DerivedAttr1-x");
x.setAttrString2("DerivedAttr2-x");
DerivedStructBaseStruct yOrig = new DerivedStructBaseStruct();
//Base
yOrig.setVarFloat(-9.14f);
yOrig.setVarInt(new BigInteger("10"));
yOrig.setVarString("BaseStruct-y");
yOrig.setVarAttrString("BaseStructAttr-y");
//Derived
yOrig.setVarFloatExt(1.414f);
yOrig.setVarStringExt("DerivedStruct-y");
yOrig.setAttrString1("DerivedAttr1-y");
yOrig.setAttrString2("DerivedAttr2-y");
Holder<DerivedStructBaseStruct> y = new Holder(yOrig);
Holder<DerivedStructBaseStruct> z = new Holder();
DerivedStructBaseStruct ret;
if (testDocLiteral) {
ret = docClient.testDerivedStructBaseStruct(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testDerivedStructBaseStruct(x, y, z);
} else {
ret = rpcClient.testDerivedStructBaseStruct(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testDerivedStructBaseStruct(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testDerivedStructBaseStruct(): Incorrect value for out param",
equals(yOrig, z.value));
assertTrue("testDerivedStructBaseStruct(): Incorrect return value", equals(x, ret));
}
}
protected boolean equals(DerivedStructBaseChoice x, DerivedStructBaseChoice y) {
return equals((SimpleChoice)x, (SimpleChoice)y)
&& (Float.compare(x.getVarFloatExt(), y.getVarFloatExt()) == 0)
&& (x.getVarStringExt().equals(y.getVarStringExt()))
&& (x.getAttrString().equals(y.getAttrString()));
}
@Test
public void testDerivedStructBaseChoice() throws Exception {
if (!shouldRunTest("DerivedStructBaseChoice")) {
return;
}
DerivedStructBaseChoice x = new DerivedStructBaseChoice();
//Base
x.setVarString("BaseChoice-x");
//Derived
x.setVarFloatExt(-3.14f);
x.setVarStringExt("DerivedStruct-x");
x.setAttrString("DerivedAttr-x");
DerivedStructBaseChoice yOrig = new DerivedStructBaseChoice();
//Base
yOrig.setVarFloat(-9.14f);
//Derived
yOrig.setVarFloatExt(1.414f);
yOrig.setVarStringExt("DerivedStruct-y");
yOrig.setAttrString("DerivedAttr-y");
Holder<DerivedStructBaseChoice> y = new Holder(yOrig);
Holder<DerivedStructBaseChoice> z = new Holder();
DerivedStructBaseChoice ret;
if (testDocLiteral) {
ret = docClient.testDerivedStructBaseChoice(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testDerivedStructBaseChoice(x, y, z);
} else {
ret = rpcClient.testDerivedStructBaseChoice(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testDerivedStructBaseChoice(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testDerivedStructBaseChoice(): Incorrect value for out param",
equals(yOrig, z.value));
assertTrue("testDerivedStructBaseChoice(): Incorrect return value", equals(x, ret));
}
}
protected boolean equals(DerivedChoiceBaseStruct x, DerivedChoiceBaseStruct y) {
boolean isEquals = x.getAttrString().equals(y.getAttrString());
if (x.getVarStringExt() != null && y.getVarStringExt() != null) {
isEquals &= x.getVarStringExt().equals(y.getVarStringExt());
} else {
isEquals &= x.getVarFloatExt() != null && y.getVarFloatExt() != null
&& x.getVarFloatExt().compareTo(y.getVarFloatExt()) == 0;
}
return isEquals && equals((SimpleStruct)x, (SimpleStruct)y);
}
@Test
public void testDerivedChoiceBaseStruct() throws Exception {
if (!shouldRunTest("DerivedChoiceBaseStruct")) {
return;
}
DerivedChoiceBaseStruct x = new DerivedChoiceBaseStruct();
//Base
x.setVarFloat(3.14f);
x.setVarInt(new BigInteger("42"));
x.setVarString("BaseStruct-x");
x.setVarAttrString("BaseStructAttr-x");
//Derived
x.setVarStringExt("DerivedChoice-x");
x.setAttrString("DerivedAttr-x");
DerivedChoiceBaseStruct yOrig = new DerivedChoiceBaseStruct();
// Base
yOrig.setVarFloat(-9.14f);
yOrig.setVarInt(new BigInteger("10"));
yOrig.setVarString("BaseStruct-y");
yOrig.setVarAttrString("BaseStructAttr-y");
// Derived
yOrig.setVarFloatExt(1.414f);
yOrig.setAttrString("DerivedAttr-y");
Holder<DerivedChoiceBaseStruct> y = new Holder(yOrig);
Holder<DerivedChoiceBaseStruct> z = new Holder();
DerivedChoiceBaseStruct ret;
if (testDocLiteral) {
ret = docClient.testDerivedChoiceBaseStruct(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testDerivedChoiceBaseStruct(x, y, z);
} else {
ret = rpcClient.testDerivedChoiceBaseStruct(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testDerivedChoiceBaseStruct(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testDerivedChoiceBaseStruct(): Incorrect value for out param",
equals(yOrig, z.value));
assertTrue("testDerivedChoiceBaseStruct(): Incorrect return value", equals(x, ret));
}
}
//org.apache.type_test.types1.DerivedChoiceBaseArray
protected boolean equals(DerivedChoiceBaseArray x, DerivedChoiceBaseArray y) {
boolean isEquals = x.getAttrStringExt().equals(y.getAttrStringExt());
if (x.getVarFloatExt() != null && y.getVarFloatExt() != null) {
isEquals &= x.getVarFloatExt().compareTo(y.getVarFloatExt()) == 0;
} else {
isEquals &= x.getVarStringExt() != null && y.getVarStringExt() != null
&& x.getVarStringExt().equals(y.getVarStringExt());
}
return isEquals && equals((UnboundedArray)x, (UnboundedArray)y);
}
@Test
public void testDerivedChoiceBaseArray() throws Exception {
if (!shouldRunTest("DerivedChoiceBaseArray")) {
return;
}
DerivedChoiceBaseArray x = new DerivedChoiceBaseArray();
//Base
x.getItem().addAll(Arrays.asList("AAA", "BBB", "CCC"));
//Derived
x.setVarStringExt("DerivedChoice-x");
x.setAttrStringExt("DerivedAttr-x");
DerivedChoiceBaseArray yOrig = new DerivedChoiceBaseArray();
//Base
yOrig.getItem().addAll(Arrays.asList("XXX", "YYY", "ZZZ"));
//Derived
yOrig.setVarFloatExt(1.414f);
yOrig.setAttrStringExt("DerivedAttr-y");
Holder<DerivedChoiceBaseArray> y = new Holder(yOrig);
Holder<DerivedChoiceBaseArray> z = new Holder();
DerivedChoiceBaseArray ret;
if (testDocLiteral) {
ret = docClient.testDerivedChoiceBaseArray(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testDerivedChoiceBaseArray(x, y, z);
} else {
ret = rpcClient.testDerivedChoiceBaseArray(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testDerivedChoiceBaseArray(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testDerivedChoiceBaseArray(): Incorrect value for out param",
equals(yOrig, z.value));
assertTrue("testDerivedChoiceBaseArray(): Incorrect return value",
equals(ret, x));
}
}
//org.apache.type_test.types1.DerivedChoiceBaseChoice
protected boolean equals(DerivedChoiceBaseChoice x, DerivedChoiceBaseChoice y) {
boolean isEquals = x.getAttrString().equals(y.getAttrString());
if (x.getVarStringExt() != null && y.getVarStringExt() != null) {
isEquals &= x.getVarStringExt().equals(y.getVarStringExt());
} else {
isEquals &= x.getVarFloatExt() != null && y.getVarFloatExt() != null
&& x.getVarFloatExt().compareTo(y.getVarFloatExt()) == 0;
}
return isEquals && equals((SimpleChoice)x, (SimpleChoice)y);
}
@Test
public void testDerivedChoiceBaseChoice() throws Exception {
if (!shouldRunTest("DerivedChoiceBaseChoice")) {
return;
}
DerivedChoiceBaseChoice x = new DerivedChoiceBaseChoice();
//Base
x.setVarString("BaseChoice-x");
//Derived
x.setVarStringExt("DerivedChoice-x");
x.setAttrString("DerivedAttr-x");
DerivedChoiceBaseChoice yOrig = new DerivedChoiceBaseChoice();
//Base
yOrig.setVarFloat(-9.14f);
//Derived
yOrig.setVarFloatExt(1.414f);
yOrig.setAttrString("DerivedAttr-y");
Holder<DerivedChoiceBaseChoice> y = new Holder(yOrig);
Holder<DerivedChoiceBaseChoice> z = new Holder();
DerivedChoiceBaseChoice ret;
if (testDocLiteral) {
ret = docClient.testDerivedChoiceBaseChoice(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testDerivedChoiceBaseChoice(x, y, z);
} else {
ret = rpcClient.testDerivedChoiceBaseChoice(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testDerivedChoiceBaseChoice(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testDerivedChoiceBaseChoice(): Incorrect value for out param",
equals(yOrig, z.value));
assertTrue("testDerivedChoiceBaseChoice(): Incorrect return value", equals(x, ret));
}
}
//org.apache.type_test.types1.DerivedNoContent
protected boolean equals(DerivedNoContent x, DerivedNoContent y) {
return equals((SimpleStruct)x, (SimpleStruct)y)
&& x.getVarAttrString().equals(y.getVarAttrString());
}
@Test
public void testDerivedNoContent() throws Exception {
if (!shouldRunTest("DerivedNoContent")) {
return;
}
DerivedNoContent x = new DerivedNoContent();
x.setVarFloat(3.14f);
x.setVarInt(new BigInteger("42"));
x.setVarString("BaseStruct-x");
x.setVarAttrString("BaseStructAttr-x");
DerivedNoContent yOrig = new DerivedNoContent();
yOrig.setVarFloat(1.414f);
yOrig.setVarInt(new BigInteger("13"));
yOrig.setVarString("BaseStruct-y");
yOrig.setVarAttrString("BaseStructAttr-y");
Holder<DerivedNoContent> y = new Holder(yOrig);
Holder<DerivedNoContent> z = new Holder();
DerivedNoContent ret;
if (testDocLiteral) {
ret = docClient.testDerivedNoContent(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testDerivedNoContent(x, y, z);
} else {
ret = rpcClient.testDerivedNoContent(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testDerivedNoContent(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testDerivedNoContent(): Incorrect value for out param",
equals(yOrig, z.value));
assertTrue("testDerivedNoContent(): Incorrect return value", equals(ret, x));
}
}
//org.apache.type_test.types1.DerivedStructBaseEmpty
protected boolean equals(DerivedStructBaseEmpty x, DerivedStructBaseEmpty y) {
return (x.getVarFloatExt() == y.getVarFloatExt())
&& (x.getVarStringExt().equals(y.getVarStringExt()))
&& (x.getAttrString().equals(y.getAttrString()));
}
@Test
public void testDerivedStructBaseEmpty() throws Exception {
if (!shouldRunTest("DerivedStructBaseEmpty")) {
return;
}
DerivedStructBaseEmpty x = new DerivedStructBaseEmpty();
//Derived
x.setVarFloatExt(-3.14f);
x.setVarStringExt("DerivedStruct-x");
x.setAttrString("DerivedAttr-x");
DerivedStructBaseEmpty yOrig = new DerivedStructBaseEmpty();
//Derived
yOrig.setVarFloatExt(1.414f);
yOrig.setVarStringExt("DerivedStruct-y");
yOrig.setAttrString("DerivedAttr-y");
Holder<DerivedStructBaseEmpty> y = new Holder(yOrig);
Holder<DerivedStructBaseEmpty> z = new Holder();
DerivedStructBaseEmpty ret;
if (testDocLiteral) {
ret = docClient.testDerivedStructBaseEmpty(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testDerivedStructBaseEmpty(x, y, z);
} else {
ret = rpcClient.testDerivedStructBaseEmpty(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testDerivedStructBaseEmpty(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testDerivedStructBaseEmpty(): Incorrect value for out param",
equals(yOrig, z.value));
assertTrue("testDerivedStructBaseEmpty(): Incorrect return value", equals(x, ret));
}
}
//org.apache.type_test.types1.DerivedEmptyBaseEmptyAll
@Test
public void testDerivedEmptyBaseEmptyAll() throws Exception {
if (!shouldRunTest("DerivedEmptyBaseEmptyAll")) {
return;
}
DerivedEmptyBaseEmptyAll x = new DerivedEmptyBaseEmptyAll();
DerivedEmptyBaseEmptyAll yOrig = new DerivedEmptyBaseEmptyAll();
Holder<DerivedEmptyBaseEmptyAll> y = new Holder(yOrig);
Holder<DerivedEmptyBaseEmptyAll> z = new Holder();
DerivedEmptyBaseEmptyAll ret;
if (testDocLiteral) {
ret = docClient.testDerivedEmptyBaseEmptyAll(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testDerivedEmptyBaseEmptyAll(x, y, z);
} else {
ret = rpcClient.testDerivedEmptyBaseEmptyAll(x, y, z);
}
// not much to check
assertNotNull(y.value);
assertNotNull(z.value);
assertNotNull(ret);
assertTrue(y.value instanceof DerivedEmptyBaseEmptyAll);
assertTrue(z.value instanceof DerivedEmptyBaseEmptyAll);
assertTrue(ret instanceof DerivedEmptyBaseEmptyAll);
}
//org.apache.type_test.types1.DerivedEmptyBaseEmptyChoice
@Test
public void testDerivedEmptyBaseEmptyChoice() throws Exception {
if (!shouldRunTest("DerivedEmptyBaseEmptyChoice")) {
return;
}
DerivedEmptyBaseEmptyChoice x = new DerivedEmptyBaseEmptyChoice();
DerivedEmptyBaseEmptyChoice yOrig = new DerivedEmptyBaseEmptyChoice();
Holder<DerivedEmptyBaseEmptyChoice> y = new Holder(yOrig);
Holder<DerivedEmptyBaseEmptyChoice> z = new Holder();
DerivedEmptyBaseEmptyChoice ret;
if (testDocLiteral) {
ret = docClient.testDerivedEmptyBaseEmptyChoice(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testDerivedEmptyBaseEmptyChoice(x, y, z);
} else {
ret = rpcClient.testDerivedEmptyBaseEmptyChoice(x, y, z);
}
// not much to check
assertNotNull(y.value);
assertNotNull(z.value);
assertNotNull(ret);
assertTrue(y.value instanceof DerivedEmptyBaseEmptyChoice);
assertTrue(z.value instanceof DerivedEmptyBaseEmptyChoice);
assertTrue(ret instanceof DerivedEmptyBaseEmptyChoice);
}
//org.apache.type_test.types1.RestrictedChoiceBaseChoice
protected boolean equals(RestrictedChoiceBaseChoice x, RestrictedChoiceBaseChoice y) {
if (x.getVarFloat() != null && y.getVarFloat() != null) {
return x.getVarFloat().compareTo(y.getVarFloat()) == 0;
} else {
return x.getVarInt() != null && y.getVarInt() != null
&& x.getVarInt().compareTo(y.getVarInt()) == 0;
}
}
@Test
public void testRestrictedChoiceBaseChoice() throws Exception {
if (!shouldRunTest("RestrictedChoiceBaseChoice")) {
return;
}
RestrictedChoiceBaseChoice x = new RestrictedChoiceBaseChoice();
x.setVarInt(12);
RestrictedChoiceBaseChoice yOrig = new RestrictedChoiceBaseChoice();
yOrig.setVarFloat(-9.14f);
Holder<RestrictedChoiceBaseChoice> y = new Holder(yOrig);
Holder<RestrictedChoiceBaseChoice> z = new Holder();
RestrictedChoiceBaseChoice ret;
if (testDocLiteral) {
ret = docClient.testRestrictedChoiceBaseChoice(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testRestrictedChoiceBaseChoice(x, y, z);
} else {
ret = rpcClient.testRestrictedChoiceBaseChoice(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testRestrictedChoiceBaseChoice(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testRestrictedChoiceBaseChoice(): Incorrect value for out param",
equals(yOrig, z.value));
assertTrue("testRestrictedChoiceBaseChoice(): Incorrect return value",
equals(x, ret));
}
}
//org.apache.type_test.types2.ComplexTypeWithAttributeGroup
protected boolean equals(ComplexTypeWithAttributeGroup x,
ComplexTypeWithAttributeGroup y) {
return x.getAttrInt().compareTo(y.getAttrInt()) == 0
&& x.getAttrString().equals(y.getAttrString());
}
@Test
public void testComplexTypeWithAttributeGroup() throws Exception {
if (!shouldRunTest("ComplexTypeWithAttributeGroup")) {
return;
}
ComplexTypeWithAttributeGroup x = new ComplexTypeWithAttributeGroup();
x.setAttrInt(new BigInteger("123"));
x.setAttrString("x123");
ComplexTypeWithAttributeGroup yOrig = new ComplexTypeWithAttributeGroup();
yOrig.setAttrInt(new BigInteger("456"));
yOrig.setAttrString("x456");
Holder<ComplexTypeWithAttributeGroup> y = new Holder(yOrig);
Holder<ComplexTypeWithAttributeGroup> z = new Holder();
ComplexTypeWithAttributeGroup ret;
if (testDocLiteral) {
ret = docClient.testComplexTypeWithAttributeGroup(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testComplexTypeWithAttributeGroup(x, y, z);
} else {
ret = rpcClient.testComplexTypeWithAttributeGroup(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testComplexTypeWithAttributeGroup(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testComplexTypeWithAttributeGroup(): Incorrect value for out param",
equals(yOrig, z.value));
assertTrue("testComplexTypeWithAttributeGroup(): Incorrect return value", equals(x, ret));
}
}
//org.apache.type_test.types2.ComplexTypeWithAttributeGroup1
protected boolean equals(ComplexTypeWithAttributeGroup1 x,
ComplexTypeWithAttributeGroup1 y) {
return x.getAttrInt().compareTo(y.getAttrInt()) == 0
&& x.getAttrFloat().compareTo(y.getAttrFloat()) == 0
&& x.getAttrString().equals(y.getAttrString());
}
@Test
public void testComplexTypeWithAttributeGroup1() throws Exception {
if (!shouldRunTest("ComplexTypeWithAttributeGroup1")) {
return;
}
ComplexTypeWithAttributeGroup1 x = new ComplexTypeWithAttributeGroup1();
x.setAttrInt(new BigInteger("123"));
x.setAttrString("x123");
x.setAttrFloat(new Float(3.14f));
ComplexTypeWithAttributeGroup1 yOrig = new ComplexTypeWithAttributeGroup1();
yOrig.setAttrInt(new BigInteger("456"));
yOrig.setAttrString("x456");
yOrig.setAttrFloat(new Float(6.28f));
Holder<ComplexTypeWithAttributeGroup1> y = new Holder(yOrig);
Holder<ComplexTypeWithAttributeGroup1> z = new Holder();
ComplexTypeWithAttributeGroup1 ret;
if (testDocLiteral) {
ret = docClient.testComplexTypeWithAttributeGroup1(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testComplexTypeWithAttributeGroup1(x, y, z);
} else {
ret = rpcClient.testComplexTypeWithAttributeGroup1(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testComplexTypeWithAttributeGroup1(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testComplexTypeWithAttributeGroup1(): Incorrect value for out param",
equals(yOrig, z.value));
assertTrue("testComplexTypeWithAttributeGroup1(): Incorrect return value", equals(x, ret));
}
}
//org.apache.type_test.types2.SequenceWithGroupSeq
protected boolean equals(SequenceWithGroupSeq x, SequenceWithGroupSeq y) {
return x.getVarInt() == y.getVarInt()
&& Float.compare(x.getVarFloat(), y.getVarFloat()) == 0
&& x.getVarString().equals(y.getVarString())
&& x.getVarOtherInt() == y.getVarOtherInt()
&& Float.compare(x.getVarOtherFloat(), y.getVarOtherFloat()) == 0
&& x.getVarOtherString().equals(y.getVarOtherString());
}
@Test
public void testSequenceWithGroupSeq() throws Exception {
if (!shouldRunTest("SequenceWithGroupSeq")) {
return;
}
SequenceWithGroupSeq x = new SequenceWithGroupSeq();
x.setVarInt(100);
x.setVarString("hello");
x.setVarFloat(1.1f);
x.setVarOtherInt(11);
x.setVarOtherString("world");
x.setVarOtherFloat(10.1f);
SequenceWithGroupSeq yOrig = new SequenceWithGroupSeq();
yOrig.setVarInt(11);
yOrig.setVarString("world");
yOrig.setVarFloat(10.1f);
yOrig.setVarOtherInt(100);
yOrig.setVarOtherString("hello");
yOrig.setVarOtherFloat(1.1f);
Holder<SequenceWithGroupSeq> y = new Holder(yOrig);
Holder<SequenceWithGroupSeq> z = new Holder();
SequenceWithGroupSeq ret;
if (testDocLiteral) {
ret = docClient.testSequenceWithGroupSeq(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testSequenceWithGroupSeq(x, y, z);
} else {
ret = rpcClient.testSequenceWithGroupSeq(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testSequenceWithGroupSeq(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testSequenceWithGroupSeq(): Incorrect value for out param",
equals(yOrig, z.value));
assertTrue("testSequenceWithGroupSeq(): Incorrect return value", equals(x, ret));
}
}
//org.apache.type_test.types2.SequenceWithGroupChoice
protected boolean equals(SequenceWithGroupChoice x, SequenceWithGroupChoice y) {
if (x.getVarInt() != null && y.getVarInt() != null) {
if (x.getVarInt().compareTo(y.getVarInt()) != 0) {
return false;
}
} else if (x.getVarFloat() != null && y.getVarFloat() != null) {
if (x.getVarFloat().compareTo(y.getVarFloat()) != 0) {
return false;
}
} else if (x.getVarString() != null && y.getVarString() != null) {
if (!x.getVarString().equals(y.getVarString())) {
return false;
}
} else {
return false;
}
if (x.getVarOtherInt() != null && y.getVarOtherInt() != null) {
if (x.getVarOtherInt().compareTo(y.getVarOtherInt()) != 0) {
return false;
}
} else if (x.getVarOtherFloat() != null && y.getVarOtherFloat() != null) {
if (x.getVarOtherFloat().compareTo(y.getVarOtherFloat()) != 0) {
return false;
}
} else if (x.getVarOtherString() != null && y.getVarOtherString() != null) {
return x.getVarOtherString().equals(y.getVarOtherString());
} else {
return false;
}
return true;
}
@Test
public void testSequenceWithGroupChoice() throws Exception {
if (!shouldRunTest("SequenceWithGroupChoice")) {
return;
}
SequenceWithGroupChoice x = new SequenceWithGroupChoice();
x.setVarFloat(1.1f);
x.setVarOtherString("world");
SequenceWithGroupChoice yOrig = new SequenceWithGroupChoice();
yOrig.setVarOtherFloat(2.2f);
yOrig.setVarString("world");
Holder<SequenceWithGroupChoice> y = new Holder(yOrig);
Holder<SequenceWithGroupChoice> z = new Holder();
SequenceWithGroupChoice ret;
if (testDocLiteral) {
ret = docClient.testSequenceWithGroupChoice(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testSequenceWithGroupChoice(x, y, z);
} else {
ret = rpcClient.testSequenceWithGroupChoice(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testSequenceWithGroupChoice(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testSequenceWithGroupChoice(): Incorrect value for out param",
equals(yOrig, z.value));
assertTrue("testSequenceWithGroupChoice(): Incorrect return value", equals(x, ret));
}
}
//org.apache.type_test.types2.SequenceWithGroups
protected boolean equals(SequenceWithGroups x, SequenceWithGroups y) {
if (x.getVarOtherInt() != null && y.getVarOtherInt() != null) {
if (x.getVarOtherInt().compareTo(y.getVarOtherInt()) != 0) {
return false;
}
} else if (x.getVarOtherFloat() != null && y.getVarOtherFloat() != null) {
if (x.getVarOtherFloat().compareTo(y.getVarOtherFloat()) != 0) {
return false;
}
} else if (x.getVarOtherString() != null && y.getVarOtherString() != null) {
if (!x.getVarOtherString().equals(y.getVarOtherString())) {
return false;
}
} else {
return false;
}
return x.getVarInt() == y.getVarInt()
&& Float.compare(x.getVarFloat(), y.getVarFloat()) == 0
&& x.getVarString().equals(y.getVarString());
}
@Test
public void testSequenceWithGroups() throws Exception {
if (!shouldRunTest("SequenceWithGroups")) {
return;
}
SequenceWithGroups x = new SequenceWithGroups();
x.setVarInt(100);
x.setVarString("hello");
x.setVarFloat(1.1f);
x.setVarOtherFloat(1.1f);
SequenceWithGroups yOrig = new SequenceWithGroups();
yOrig.setVarInt(11);
yOrig.setVarString("world");
yOrig.setVarFloat(10.1f);
yOrig.setVarOtherString("world");
Holder<SequenceWithGroups> y = new Holder(yOrig);
Holder<SequenceWithGroups> z = new Holder();
SequenceWithGroups ret;
if (testDocLiteral) {
ret = docClient.testSequenceWithGroups(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testSequenceWithGroups(x, y, z);
} else {
ret = rpcClient.testSequenceWithGroups(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testSequenceWithGroups(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testSequenceWithGroups(): Incorrect value for out param",
equals(yOrig, z.value));
assertTrue("testSequenceWithGroups(): Incorrect return value", equals(x, ret));
}
}
//org.apache.type_test.types2.SequenceWithOccuringGroup
protected boolean equals(SequenceWithOccuringGroup x, SequenceWithOccuringGroup y) {
return equalsFloatIntStringList(x.getBatchElementsSeq(), y.getBatchElementsSeq());
}
@Test
public void testSequenceWithOccuringGroup() throws Exception {
if (!shouldRunTest("SequenceWithOccuringGroup")) {
return;
}
SequenceWithOccuringGroup x = new SequenceWithOccuringGroup();
x.getBatchElementsSeq().add(1.1f);
x.getBatchElementsSeq().add(100);
x.getBatchElementsSeq().add("hello");
SequenceWithOccuringGroup yOrig = new SequenceWithOccuringGroup();
yOrig.getBatchElementsSeq().add(2.2f);
yOrig.getBatchElementsSeq().add(200);
yOrig.getBatchElementsSeq().add("world");
Holder<SequenceWithOccuringGroup> y = new Holder(yOrig);
Holder<SequenceWithOccuringGroup> z = new Holder();
SequenceWithOccuringGroup ret;
if (testDocLiteral) {
ret = docClient.testSequenceWithOccuringGroup(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testSequenceWithOccuringGroup(x, y, z);
} else {
ret = rpcClient.testSequenceWithOccuringGroup(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testGroupDirectlyInComplexType(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testGroupDirectlyInComplexType(): Incorrect value for out param",
equals(yOrig, z.value));
assertTrue("testGroupDirectlyInComplexType(): Incorrect return value", equals(x, ret));
}
}
//org.apache.type_test.types2.GroupDirectlyInComplexType
protected boolean equals(GroupDirectlyInComplexType x, GroupDirectlyInComplexType y) {
return x.getVarInt() == y.getVarInt()
&& x.getVarString().equals(y.getVarString())
&& Float.compare(x.getVarFloat(), y.getVarFloat()) == 0
&& x.getAttr1().equals(y.getAttr1());
}
@Test
public void testGroupDirectlyInComplexType() throws Exception {
if (!shouldRunTest("GroupDirectlyInComplexType")) {
return;
}
GroupDirectlyInComplexType x = new GroupDirectlyInComplexType();
x.setVarInt(100);
x.setVarString("hello");
x.setVarFloat(1.1f);
x.setAttr1(new Integer(1));
GroupDirectlyInComplexType yOrig = new GroupDirectlyInComplexType();
yOrig.setVarInt(11);
yOrig.setVarString("world");
yOrig.setVarFloat(10.1f);
yOrig.setAttr1(new Integer(2));
Holder<GroupDirectlyInComplexType> y = new Holder(yOrig);
Holder<GroupDirectlyInComplexType> z = new Holder();
GroupDirectlyInComplexType ret;
if (testDocLiteral) {
ret = docClient.testGroupDirectlyInComplexType(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testGroupDirectlyInComplexType(x, y, z);
} else {
ret = rpcClient.testGroupDirectlyInComplexType(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testGroupDirectlyInComplexType(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testGroupDirectlyInComplexType(): Incorrect value for out param",
equals(yOrig, z.value));
assertTrue("testGroupDirectlyInComplexType(): Incorrect return value", equals(x, ret));
}
}
//org.apache.type_test.types2.ComplexTypeWithAttributes
protected boolean equals(ComplexTypeWithAttributes x, ComplexTypeWithAttributes y) {
return x.getAttrInt().equals(y.getAttrInt())
&& x.getAttrString().equals(y.getAttrString());
}
@Test
public void testComplexTypeWithAttributes() throws Exception {
if (!shouldRunTest("ComplexTypeWithAttributes")) {
return;
}
ComplexTypeWithAttributes x = new ComplexTypeWithAttributes();
x.setAttrInt(new BigInteger("123"));
x.setAttrString("x123");
ComplexTypeWithAttributes yOrig = new ComplexTypeWithAttributes();
yOrig.setAttrInt(new BigInteger("456"));
yOrig.setAttrString("x456");
Holder<ComplexTypeWithAttributes> y = new Holder(yOrig);
Holder<ComplexTypeWithAttributes> z = new Holder();
ComplexTypeWithAttributes ret;
if (testDocLiteral) {
ret = docClient.testComplexTypeWithAttributes(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testComplexTypeWithAttributes(x, y, z);
} else {
ret = rpcClient.testComplexTypeWithAttributes(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testComplexTypeWithAttributes(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testComplexTypeWithAttributes(): Incorrect value for out param",
equals(yOrig, z.value));
assertTrue("testComplexTypeWithAttributes(): Incorrect return value", equals(x, ret));
}
}
//org.apache.type_test.types2.StructWithAny
public void assertEqualsStructWithAny(StructWithAny a, StructWithAny b) throws Exception {
assertEquals("StructWithAny names don't match", a.getName(), b.getName());
assertEquals("StructWithAny addresses don't match", a.getAddress(), b.getAddress());
assertEquals(a.getAny(), b.getAny());
}
public void assertEquals(Element elA, Element elB) throws Exception {
if (elA instanceof SOAPElement && elB instanceof SOAPElement) {
SOAPElement soapA = (SOAPElement)elA;
SOAPElement soapB = (SOAPElement)elB;
assertEquals("StructWithAny soap element names don't match",
soapA.getElementName(), soapB.getElementName());
assertEquals("StructWithAny soap element text nodes don't match",
soapA.getValue(), soapB.getValue());
Iterator itExp = soapA.getChildElements();
Iterator itGen = soapB.getChildElements();
while (itExp.hasNext()) {
if (!itGen.hasNext()) {
fail("Incorrect number of child elements inside any");
}
Object objA = itExp.next();
Object objB = itGen.next();
if (objA instanceof SOAPElement) {
if (objB instanceof SOAPElement) {
assertEquals((SOAPElement)objA, (SOAPElement)objB);
} else {
fail("No matching soap element.");
}
}
}
}
}
@Test
public void testStructWithAny() throws Exception {
if (!shouldRunTest("StructWithAny")) {
return;
}
StructWithAny swa = new StructWithAny();
swa.setName("Name");
swa.setAddress("Some Address");
StructWithAny yOrig = new StructWithAny();
yOrig.setName("Name2");
yOrig.setAddress("Some Other Address");
SOAPFactory factory = SOAPFactory.newInstance();
SOAPElement x = factory.createElement("hello", "foo", "http://some.url.com");
x.addNamespaceDeclaration("foo", "http://some.url.com");
x.addTextNode("This is the text of the node");
SOAPElement x2 = factory.createElement("hello2", "foo", "http://some.url.com");
x2.addNamespaceDeclaration("foo", "http://some.url.com");
x2.addTextNode("This is the text of the node for the second struct");
swa.setAny(x);
yOrig.setAny(x2);
Holder<StructWithAny> y = new Holder(yOrig);
Holder<StructWithAny> z = new Holder();
StructWithAny ret;
if (testDocLiteral) {
ret = docClient.testStructWithAny(swa, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testStructWithAny(swa, y, z);
} else {
ret = rpcClient.testStructWithAny(swa, y, z);
}
if (!perfTestOnly) {
assertEqualsStructWithAny(swa, y.value);
assertEqualsStructWithAny(yOrig, z.value);
assertEqualsStructWithAny(swa, ret);
}
}
@Test
public void testStructWithAnyXsi() throws Exception {
if (!shouldRunTest("StructWithAnyXsi")) {
return;
}
StructWithAny swa = new StructWithAny();
swa.setName("Name");
swa.setAddress("Some Address");
StructWithAny yOrig = new StructWithAny();
yOrig.setName("Name2");
yOrig.setAddress("Some Other Address");
SOAPFactory sf = SOAPFactory.newInstance();
Name elementName = sf.createName("UKAddress", "", "http://apache.org/type_test");
Name xsiAttrName = sf.createName("type", "xsi", "http://www.w3.org/2001/XMLSchema-instance");
SOAPElement x = sf.createElement(elementName);
x.addNamespaceDeclaration("tns", "http://apache.org/type_test");
x.addNamespaceDeclaration("xsi", "http://www.w3.org/2001/XMLSchema-instance");
x.addAttribute(xsiAttrName, "tns:UKAddressType11");
x.addTextNode("This is the text of the node for the first struct");
Name elementName2 = sf.createName("UKAddress", "", "http://apache.org/type_test");
Name xsiAttrName2 = sf.createName("type", "xsi", "http://www.w3.org/2001/XMLSchema-instance");
SOAPElement x2 = sf.createElement(elementName2);
x2.addNamespaceDeclaration("tns", "http://apache.org/type_test");
x2.addNamespaceDeclaration("xsi", "http://www.w3.org/2001/XMLSchema-instance");
x2.addAttribute(xsiAttrName2, "tns:UKAddressType22");
x2.addTextNode("This is the text of the node for the second struct");
swa.setAny(x);
yOrig.setAny(x2);
Holder<StructWithAny> y = new Holder(yOrig);
Holder<StructWithAny> z = new Holder();
StructWithAny ret;
if (testDocLiteral) {
ret = docClient.testStructWithAny(swa, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testStructWithAny(swa, y, z);
} else {
ret = rpcClient.testStructWithAny(swa, y, z);
}
if (!perfTestOnly) {
assertEqualsStructWithAny(swa, y.value);
assertEqualsStructWithAny(yOrig, z.value);
assertEqualsStructWithAny(swa, ret);
}
}
// StructWithInvalidAny
// XXX - no exception thrown
@Test
public void testStructWithInvalidAny() throws Exception {
if (!shouldRunTest("StructWithInvalidAny")) {
return;
}
StructWithAny swa = new StructWithAny();
swa.setName("Name");
swa.setAddress("Some Address");
StructWithAny yOrig = new StructWithAny();
yOrig.setName("Name2");
yOrig.setAddress("Some Other Address");
SOAPFactory factory = SOAPFactory.newInstance();
SOAPElement x = factory.createElement("hello", "foo", "http://some.url.com");
x.addTextNode("This is the text of the node");
SOAPElement x2 = factory.createElement("hello2", "foo", "http://some.url.com");
x2.addTextNode("This is the text of the node for the second struct");
swa.setAny(x);
yOrig.setAny(x2);
Holder<StructWithAny> y = new Holder(yOrig);
Holder<StructWithAny> z = new Holder();
try {
if (testDocLiteral) {
docClient.testStructWithAny(swa, y, z);
} else if (testXMLBinding) {
xmlClient.testStructWithAny(swa, y, z);
} else {
rpcClient.testStructWithAny(swa, y, z);
}
//fail("testStructWithInvalidAny(): Did not catch expected exception.");
} catch (Exception ex) {
fail("testStructWithInvalidAny(): caught expected exception - woot.");
}
}
//org.apache.type_test.types2.StructWithAnyArray
public void assertEqualsStructWithAnyArray(StructWithAnyArray a, StructWithAnyArray b) throws Exception {
assertEquals("StructWithAny names don't match", a.getName(), b.getName());
assertEquals("StructWithAny addresses don't match", a.getAddress(), b.getAddress());
List<Element> ae = a.getAny();
List<Element> be = b.getAny();
assertEquals("StructWithAny soap element lengths don't match", ae.size(), be.size());
for (int i = 0; i < ae.size(); i++) {
assertEquals(ae.get(i), be.get(i));
}
}
@Test
public void testStructWithAnyArray() throws Exception {
if (!shouldRunTest("StructWithAnyArray")) {
return;
}
StructWithAnyArray swa = new StructWithAnyArray();
swa.setName("Name");
swa.setAddress("Some Address");
StructWithAnyArray yOrig = new StructWithAnyArray();
yOrig.setName("Name2");
yOrig.setAddress("Some Other Address");
SOAPFactory factory = SOAPFactory.newInstance();
SOAPElement x = factory.createElement("hello", "foo", "http://some.url.com");
x.addNamespaceDeclaration("foo", "http://some.url.com");
x.addTextNode("This is the text of the node");
SOAPElement x2 = factory.createElement("hello2", "foo", "http://some.url.com");
x2.addNamespaceDeclaration("foo", "http://some.url.com");
x2.addTextNode("This is the text of the node for the second struct");
swa.getAny().add(x);
yOrig.getAny().add(x2);
Holder<StructWithAnyArray> y = new Holder(yOrig);
Holder<StructWithAnyArray> z = new Holder();
StructWithAnyArray ret;
if (testDocLiteral) {
ret = docClient.testStructWithAnyArray(swa, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testStructWithAnyArray(swa, y, z);
} else {
ret = rpcClient.testStructWithAnyArray(swa, y, z);
}
if (!perfTestOnly) {
assertEqualsStructWithAnyArray(swa, y.value);
assertEqualsStructWithAnyArray(yOrig, z.value);
assertEqualsStructWithAnyArray(swa, ret);
}
}
// StructWithInvalidAnyArray
// XXX - no exception thrown
@Test
public void testStructWithInvalidAnyArray() throws Exception {
if (!shouldRunTest("StructWithInvalidAnyArray")) {
return;
}
StructWithAnyArray swa = new StructWithAnyArray();
swa.setName("Name");
swa.setAddress("Some Address");
StructWithAnyArray yOrig = new StructWithAnyArray();
yOrig.setName("Name2");
yOrig.setAddress("Some Other Address");
SOAPFactory factory = SOAPFactory.newInstance();
SOAPElement x = factory.createElement("hello", "foo", "http://some.url.com");
x.addTextNode("This is the text of the node");
SOAPElement x2 = factory.createElement("hello2", "foo", "http://some.url.com");
x2.addTextNode("This is the text of the node for the second struct");
swa.getAny().add(x);
yOrig.getAny().add(x2);
Holder<StructWithAnyArray> y = new Holder(yOrig);
Holder<StructWithAnyArray> z = new Holder();
try {
if (testDocLiteral) {
docClient.testStructWithAnyArray(swa, y, z);
} else if (testXMLBinding) {
xmlClient.testStructWithAnyArray(swa, y, z);
} else {
rpcClient.testStructWithAnyArray(swa, y, z);
}
//fail("testStructWithInvalidAnyArray(): Did not catch expected exception.");
} catch (Exception ex) {
// Expected
fail("testStructWithInvalidAnyArray(): caught expected exception - woot.");
}
}
@Test
@Ignore
public void testStructWithAnyStrict() throws Exception {
if (!shouldRunTest("StructWithAnyStrict")) {
return;
}
// XXX - only added to the soap typetest
}
@Test
@Ignore
public void testStructWithAnyArrayLax() throws Exception {
if (!shouldRunTest("StructWithAnyArrayLax")) {
return;
}
// XXX - only added to the soap typetest
}
//org.apache.type_test.types2.IDTypeAttribute
protected boolean equalsIDTypeAttribute(IDTypeAttribute x, IDTypeAttribute y) {
return equalsNilable(x.getId(), y.getId());
}
@Test
public void testIDTypeAttribute() throws Exception {
if (!shouldRunTest("IDTypeAttribute")) {
return;
}
// n.b. to be valid elements with an ID in the response message
// must have a unique ID, so this test does not return x as the
// return value (like the other tests).
IDTypeAttribute x = new IDTypeAttribute();
x.setId("x123");
IDTypeAttribute yOrig = new IDTypeAttribute();
yOrig.setId("x456");
Holder<IDTypeAttribute> y = new Holder(yOrig);
Holder<IDTypeAttribute> z = new Holder();
//IDTypeAttribute ret;
if (testDocLiteral) {
/*ret =*/ docClient.testIDTypeAttribute(x, y, z);
} else if (testXMLBinding) {
/*ret =*/ xmlClient.testIDTypeAttribute(x, y, z);
} else {
/*ret =*/ rpcClient.testIDTypeAttribute(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testIDTypeAttribute(): Incorrect value for inout param",
equalsIDTypeAttribute(x, y.value));
assertTrue("testIDTypeAttribute(): Incorrect value for out param",
equalsIDTypeAttribute(yOrig, z.value));
}
}
//org.apache.type_test.types2.MultipleOccursSequenceInSequence
protected boolean equals(MultipleOccursSequenceInSequence x, MultipleOccursSequenceInSequence y) {
int size = x.getValue().size();
if (size != y.getValue().size()) {
return false;
}
for (int i = 0; i < size; i++) {
if (x.getValue().get(i).compareTo(y.getValue().get(i)) != 0) {
return false;
}
}
return true;
}
@Test
public void testMultipleOccursSequenceInSequence() throws Exception {
if (!shouldRunTest("MultipleOccursSequenceInSequence")) {
return;
}
MultipleOccursSequenceInSequence x = new MultipleOccursSequenceInSequence();
x.getValue().add(new BigInteger("32"));
MultipleOccursSequenceInSequence yOriginal = new MultipleOccursSequenceInSequence();
yOriginal.getValue().add(new BigInteger("3200"));
Holder<MultipleOccursSequenceInSequence> y =
new Holder<MultipleOccursSequenceInSequence>(yOriginal);
Holder<MultipleOccursSequenceInSequence> z =
new Holder<MultipleOccursSequenceInSequence>();
MultipleOccursSequenceInSequence ret;
if (testDocLiteral) {
ret = docClient.testMultipleOccursSequenceInSequence(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testMultipleOccursSequenceInSequence(x, y, z);
} else {
ret = rpcClient.testMultipleOccursSequenceInSequence(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testMultipleOccursSequenceInSequence(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testMultipleOccursSequenceInSequence(): Incorrect value for out param",
equals(yOriginal, z.value));
assertTrue("testMultipleOccursSequenceInSequence(): Incorrect return value",
equals(x, ret));
}
}
//org.apache.type_test.types2.StructWithBinary;
protected boolean equals(StructWithBinary x, StructWithBinary y) {
return Arrays.equals(x.getBase64(), y.getBase64())
&& Arrays.equals(x.getHex(), y.getHex());
}
@Test
public void testStructWithBinary() throws Exception {
if (!shouldRunTest("StructWithBinary")) {
return;
}
StructWithBinary x = new StructWithBinary();
x.setBase64("base64Binary_x".getBytes());
x.setHex("hexBinary_x".getBytes());
StructWithBinary yOriginal = new StructWithBinary();
yOriginal.setBase64("base64Binary_y".getBytes());
yOriginal.setHex("hexBinary_y".getBytes());
Holder<StructWithBinary> y = new Holder(yOriginal);
Holder<StructWithBinary> z = new Holder();
StructWithBinary ret;
if (testDocLiteral) {
ret = docClient.testStructWithBinary(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testStructWithBinary(x, y, z);
} else {
ret = rpcClient.testStructWithBinary(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testStructWithBinary(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testStructWithBinary(): Incorrect value for out param",
equals(yOriginal, z.value));
assertTrue("testStructWithBinary(): Incorrect return value",
equals(x, ret));
}
}
//org.apache.type_test.types2.ChoiceWithBinary;
protected boolean equals(ChoiceWithBinary x, ChoiceWithBinary y) {
if (x.getBase64() != null && y.getBase64() != null) {
return Arrays.equals(x.getBase64(), y.getBase64());
} else {
return x.getHex() != null && y.getHex() != null
&& Arrays.equals(x.getHex(), y.getHex());
}
}
@Test
public void testChoiceWithBinary() throws Exception {
if (!shouldRunTest("ChoiceWithBinary")) {
return;
}
ChoiceWithBinary x = new ChoiceWithBinary();
x.setBase64("base64Binary_x".getBytes());
ChoiceWithBinary yOriginal = new ChoiceWithBinary();
yOriginal.setHex("hexBinary_y".getBytes());
Holder<ChoiceWithBinary> y = new Holder(yOriginal);
Holder<ChoiceWithBinary> z = new Holder();
ChoiceWithBinary ret;
if (testDocLiteral) {
ret = docClient.testChoiceWithBinary(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testChoiceWithBinary(x, y, z);
} else {
ret = rpcClient.testChoiceWithBinary(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testChoiceWithBinary(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testChoiceWithBinary(): Incorrect value for out param",
equals(yOriginal, z.value));
assertTrue("testChoiceWithBinary(): Incorrect return value",
equals(x, ret));
}
}
//org.apache.type_test.types2.ChoiceWithGroupChoice;
protected boolean equals(ChoiceWithGroupChoice x, ChoiceWithGroupChoice y) {
if (x.getVarFloat() != null && y.getVarFloat() != null) {
return x.getVarFloat().compareTo(y.getVarFloat()) == 0;
}
if (x.getVarInt() != null && y.getVarInt() != null) {
return x.getVarInt().compareTo(y.getVarInt()) == 0;
}
if (x.getVarString() != null && y.getVarString() != null) {
return x.getVarString().equals(y.getVarString());
}
if (x.getVarOtherFloat() != null && y.getVarOtherFloat() != null) {
return x.getVarOtherFloat().compareTo(y.getVarOtherFloat()) == 0;
}
if (x.getVarOtherInt() != null && y.getVarOtherInt() != null) {
return x.getVarOtherInt().compareTo(y.getVarOtherInt()) == 0;
}
if (x.getVarOtherString() != null && y.getVarOtherString() != null) {
return x.getVarOtherString().equals(y.getVarOtherString());
}
return false;
}
// XXX - Generated code flattens nested choice
@Test
public void testChoiceWithGroupChoice() throws Exception {
if (!shouldRunTest("ChoiceWithGroupChoice")) {
return;
}
ChoiceWithGroupChoice x = new ChoiceWithGroupChoice();
x.setVarFloat(1.1f);
ChoiceWithGroupChoice yOrig = new ChoiceWithGroupChoice();
yOrig.setVarOtherString("world");
Holder<ChoiceWithGroupChoice> y = new Holder(yOrig);
Holder<ChoiceWithGroupChoice> z = new Holder();
ChoiceWithGroupChoice ret;
if (testDocLiteral) {
ret = docClient.testChoiceWithGroupChoice(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testChoiceWithGroupChoice(x, y, z);
} else {
ret = rpcClient.testChoiceWithGroupChoice(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testChoiceWithGroupChoice(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testChoiceWithGroupChoice(): Incorrect value for out param",
equals(yOrig, z.value));
assertTrue("testChoiceWithGroupChoice(): Incorrect return value",
equals(x, ret));
}
}
//org.apache.type_test.types2.ChoiceWithGroupSeq;
protected boolean equals(ChoiceWithGroupSeq x, ChoiceWithGroupSeq y) {
if (x.getVarInt() != null && x.getVarFloat() != null
&& x.getVarString() != null) {
if (x.getVarInt().compareTo(y.getVarInt()) != 0) {
return false;
}
if (x.getVarFloat().compareTo(y.getVarFloat()) != 0) {
return false;
}
return x.getVarString().equals(y.getVarString());
}
if (x.getVarOtherInt() != null && x.getVarOtherFloat() != null
&& x.getVarOtherString() != null) {
if (x.getVarOtherInt().compareTo(y.getVarOtherInt()) != 0) {
return false;
}
if (x.getVarOtherFloat().compareTo(y.getVarOtherFloat()) != 0) {
return false;
}
return x.getVarOtherString().equals(y.getVarOtherString());
}
return false;
}
// XXX - Generated code flattens nested structs
@Test
public void testChoiceWithGroupSeq() throws Exception {
if (!shouldRunTest("ChoiceWithGroupSeq")) {
return;
}
ChoiceWithGroupSeq x = new ChoiceWithGroupSeq();
x.setVarInt(100);
x.setVarString("hello");
x.setVarFloat(1.1f);
ChoiceWithGroupSeq yOrig = new ChoiceWithGroupSeq();
yOrig.setVarOtherInt(11);
yOrig.setVarOtherString("world");
yOrig.setVarOtherFloat(10.1f);
Holder<ChoiceWithGroupSeq> y = new Holder(yOrig);
Holder<ChoiceWithGroupSeq> z = new Holder();
ChoiceWithGroupSeq ret;
if (testDocLiteral) {
ret = docClient.testChoiceWithGroupSeq(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testChoiceWithGroupSeq(x, y, z);
} else {
ret = rpcClient.testChoiceWithGroupSeq(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testChoiceWithGroupSeq(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testChoiceWithGroupSeq(): Incorrect value for out param",
equals(yOrig, z.value));
assertTrue("testChoiceWithGroupSeq(): Incorrect return value",
equals(x, ret));
}
}
//org.apache.type_test.types2.ChoiceWithGroups;
protected boolean equals(ChoiceWithGroups x, ChoiceWithGroups y) {
if (x.getVarInt() != null && x.getVarString() != null
&& x.getVarFloat() != null) {
if (x.getVarInt().compareTo(y.getVarInt()) == 0
&& x.getVarString().equals(y.getVarString())
&& x.getVarFloat().compareTo(y.getVarFloat()) == 0) {
return true;
}
return false;
} else {
if (x.getVarOtherFloat() != null && y.getVarOtherFloat() != null) {
return x.getVarOtherFloat().compareTo(y.getVarOtherFloat()) == 0;
}
if (x.getVarOtherInt() != null && y.getVarOtherInt() != null) {
return x.getVarOtherInt().compareTo(y.getVarOtherInt()) == 0;
}
if (x.getVarOtherString() != null && y.getVarOtherString() != null) {
return x.getVarOtherString().equals(y.getVarOtherString());
}
return false;
}
}
// XXX - Generated code flattens nested structs
@Test
public void testChoiceWithGroups() throws Exception {
if (!shouldRunTest("ChoiceWithGroups")) {
return;
}
ChoiceWithGroups x = new ChoiceWithGroups();
x.setVarInt(100);
x.setVarString("hello");
x.setVarFloat(1.1f);
ChoiceWithGroups yOrig = new ChoiceWithGroups();
yOrig.setVarOtherString("world");
Holder<ChoiceWithGroups> y = new Holder(yOrig);
Holder<ChoiceWithGroups> z = new Holder();
ChoiceWithGroups ret;
if (testDocLiteral) {
ret = docClient.testChoiceWithGroups(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testChoiceWithGroups(x, y, z);
} else {
ret = rpcClient.testChoiceWithGroups(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testChoiceWithGroups(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testChoiceWithGroups(): Incorrect value for out param",
equals(yOrig, z.value));
assertTrue("testChoiceWithGroups(): Incorrect return value",
equals(x, ret));
}
}
//org.apache.type_test.types2.ExtBase64Binary;
protected boolean equals(ExtBase64Binary x, ExtBase64Binary y) {
return x.getId() == y.getId() && Arrays.equals(x.getValue(), y.getValue());
}
@Test
public void testExtBase64Binary() throws Exception {
if (!shouldRunTest("ExtBase64Binary")) {
return;
}
ExtBase64Binary x1 = new ExtBase64Binary();
x1.setValue("base64a".getBytes());
x1.setId(1);
ExtBase64Binary y1 = new ExtBase64Binary();
y1.setValue("base64b".getBytes());
y1.setId(2);
Holder<ExtBase64Binary> y1Holder = new Holder(y1);
Holder<ExtBase64Binary> z1 = new Holder();
ExtBase64Binary ret;
if (testDocLiteral) {
ret = docClient.testExtBase64Binary(x1, y1Holder, z1);
} else if (testXMLBinding) {
ret = xmlClient.testExtBase64Binary(x1, y1Holder, z1);
} else {
ret = rpcClient.testExtBase64Binary(x1, y1Holder, z1);
}
if (!perfTestOnly) {
assertTrue("testExtBase64Binary(): Incorrect value for inout param",
equals(x1, y1Holder.value));
assertTrue("testExtBase64Binary(): Incorrect value for out param",
equals(y1, z1.value));
assertTrue("testExtBase64Binary(): Incorrect return value", equals(x1, ret));
}
}
//org.apache.type_test.types2.StructWithAnyAttribute;
protected boolean equals(StructWithAnyAttribute x, StructWithAnyAttribute y) {
if (!(x.getVarString().equals(y.getVarString()))
|| (x.getVarInt() != y.getVarInt())) {
return false;
}
if (!equalsNilable(x.getAtString(), y.getAtString())
|| !equalsNilable(x.getAtInt(), y.getAtInt())) {
return false;
}
return equalsQNameStringPairs(x.getOtherAttributes(), y.getOtherAttributes());
}
protected boolean equalsQNameStringPairs(Map<QName, String> x, Map y) {
if ((x == null && y != null)
|| (x != null && y == null)) {
return false;
}
if (x.isEmpty() && y.isEmpty()) {
return true;
}
if (x.size() != y.size()) {
return false;
}
Iterator<QName> itx = x.keySet().iterator();
while (itx.hasNext()) {
QName attName = itx.next();
if (attName == null) {
return false;
}
String attValue = y.get(attName);
if (attValue == null || !attValue.equals(x.get(attName))) {
return false;
}
}
return true;
}
@Test
public void testStructWithAnyAttribute() throws Exception {
if (!shouldRunTest("StructWithAnyAttribute")) {
return;
}
QName xAt1Name = new QName("http://schemas.iona.com/type_test", "at_one");
QName xAt2Name = new QName("http://schemas.iona.com/type_test", "at_two");
QName yAt3Name = new QName("http://apache.org/type_test", "at_thr");
QName yAt4Name = new QName("http://apache.org/type_test", "at_fou");
StructWithAnyAttribute x = new StructWithAnyAttribute();
StructWithAnyAttribute y = new StructWithAnyAttribute();
x.setVarString("hello");
x.setVarInt(1000);
x.setAtString("hello attribute");
x.setAtInt(new Integer(2000));
y.setVarString("there");
y.setVarInt(1001);
y.setAtString("there attribute");
y.setAtInt(new Integer(2002));
Map<QName, String> xAttrMap = x.getOtherAttributes();
xAttrMap.put(xAt1Name, "one");
xAttrMap.put(xAt2Name, "two");
Map<QName, String> yAttrMap = y.getOtherAttributes();
yAttrMap.put(yAt3Name, "three");
yAttrMap.put(yAt4Name, "four");
Holder<StructWithAnyAttribute> yh = new Holder(y);
Holder<StructWithAnyAttribute> zh = new Holder();
StructWithAnyAttribute ret;
if (testDocLiteral) {
ret = docClient.testStructWithAnyAttribute(x, yh, zh);
} else if (testXMLBinding) {
ret = xmlClient.testStructWithAnyAttribute(x, yh, zh);
} else {
ret = rpcClient.testStructWithAnyAttribute(x, yh, zh);
}
if (!perfTestOnly) {
assertTrue("testStructWithAnyAttribute(): Incorrect value for inout param",
equals(x, yh.value));
assertTrue("testStructWithAnyAttribute(): Incorrect value for out param",
equals(y, zh.value));
assertTrue("testStructWithAnyAttribute(): Incorrect return value",
equals(ret, x));
}
}
//org.apache.type_test.types2.ChoiceWithAnyAttribute;
protected boolean equals(ChoiceWithAnyAttribute x, ChoiceWithAnyAttribute y) {
String xString = x.getVarString();
String yString = y.getVarString();
Integer xInt = x.getVarInt();
Integer yInt = y.getVarInt();
if (xString != null) {
if (yString == null || !xString.equals(yString)) {
fail(xString + " != " + yString);
return false;
}
} else if (xInt != null) {
if (yInt == null || !(xInt.equals(yInt))) {
fail(xInt + " != " + yInt);
return false;
}
} else {
fail("null choice");
return false;
}
if (!equalsNilable(x.getAtString(), y.getAtString())
|| !equalsNilable(x.getAtInt(), y.getAtInt())) {
fail("grrr");
return false;
}
return equalsQNameStringPairs(x.getOtherAttributes(), y.getOtherAttributes());
}
@Test
public void testChoiceWithAnyAttribute() throws Exception {
if (!shouldRunTest("ChoiceWithAnyAttribute")) {
return;
}
QName xAt1Name = new QName("http://schemas.iona.com/type_test", "at_one");
QName xAt2Name = new QName("http://schemas.iona.com/type_test", "at_two");
QName yAt3Name = new QName("http://apache.org/type_test", "at_thr");
QName yAt4Name = new QName("http://apache.org/type_test", "at_fou");
ChoiceWithAnyAttribute x = new ChoiceWithAnyAttribute();
ChoiceWithAnyAttribute y = new ChoiceWithAnyAttribute();
x.setVarString("hello");
x.setAtString("hello attribute");
x.setAtInt(new Integer(2000));
y.setVarInt(1001);
y.setAtString("there attribute");
y.setAtInt(new Integer(2002));
Map<QName, String> xAttrMap = x.getOtherAttributes();
xAttrMap.put(xAt1Name, "one");
xAttrMap.put(xAt2Name, "two");
Map<QName, String> yAttrMap = y.getOtherAttributes();
yAttrMap.put(yAt3Name, "three");
yAttrMap.put(yAt4Name, "four");
Holder<ChoiceWithAnyAttribute> yh = new Holder(y);
Holder<ChoiceWithAnyAttribute> zh = new Holder();
ChoiceWithAnyAttribute ret;
if (testDocLiteral) {
ret = docClient.testChoiceWithAnyAttribute(x, yh, zh);
} else if (testXMLBinding) {
ret = xmlClient.testChoiceWithAnyAttribute(x, yh, zh);
} else {
ret = rpcClient.testChoiceWithAnyAttribute(x, yh, zh);
}
if (!perfTestOnly) {
assertTrue("testChoiceWithAnyAttribute(): Incorrect value for inout param",
equals(x, yh.value));
assertTrue("testChoiceWithAnyAttribute(): Incorrect value for out param",
equals(y, zh.value));
assertTrue("testChoiceWithAnyAttribute(): Incorrect return value",
equals(ret, x));
}
}
//org.apache.type_test.types3.OccuringStruct;
protected boolean equals(OccuringStruct x, OccuringStruct y) {
if (!equalsNilable(x.getVarAttrib(), y.getVarAttrib())) {
return false;
}
return equalsFloatIntStringList(x.getVarFloatAndVarIntAndVarString(),
y.getVarFloatAndVarIntAndVarString());
}
protected boolean equalsFloatIntStringList(List<Serializable> xList,
List<Serializable> yList) {
int size = xList.size();
if (size != yList.size()) {
return false;
}
for (int i = 0; i < size; i++) {
if (xList.get(i) instanceof Float && yList.get(i) instanceof Float) {
Float fx = (Float)xList.get(i);
Float fy = (Float)yList.get(i);
if (fx.compareTo(fy) != 0) {
return false;
}
} else if (xList.get(i) instanceof Integer && yList.get(i) instanceof Integer) {
Integer ix = (Integer)xList.get(i);
Integer iy = (Integer)yList.get(i);
if (iy.compareTo(ix) != 0) {
return false;
}
} else if (xList.get(i) instanceof String && yList.get(i) instanceof String) {
String sx = (String)xList.get(i);
String sy = (String)yList.get(i);
if (!sx.equals(sy)) {
return false;
}
} else {
return false;
}
}
return true;
}
@Test
public void testOccuringStruct() throws Exception {
if (!shouldRunTest("OccuringStruct")) {
return;
}
OccuringStruct x = new OccuringStruct();
List<Serializable> theList = x.getVarFloatAndVarIntAndVarString();
theList.add(1.14f);
theList.add(new Integer(0));
theList.add("x1");
theList.add(11.14f);
theList.add(new Integer(1));
theList.add("x2");
x.setVarAttrib("x_attr");
OccuringStruct yOriginal = new OccuringStruct();
theList = yOriginal.getVarFloatAndVarIntAndVarString();
theList.add(3.14f);
theList.add(new Integer(42));
theList.add("y");
yOriginal.setVarAttrib("y_attr");
Holder<OccuringStruct> y = new Holder(yOriginal);
Holder<OccuringStruct> z = new Holder();
OccuringStruct ret;
if (testDocLiteral) {
ret = docClient.testOccuringStruct(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testOccuringStruct(x, y, z);
} else {
ret = rpcClient.testOccuringStruct(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testOccuringStruct(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testOccuringStruct(): Incorrect value for out param",
equals(yOriginal, z.value));
assertTrue("testOccuringStruct(): Incorrect return value",
equals(x, ret));
}
}
//org.apache.type_test.types3.OccuringStruct1;
protected boolean equals(OccuringStruct1 x, OccuringStruct1 y) {
return equalsFloatIntStringList(x.getVarFloatAndVarIntAndVarString(),
y.getVarFloatAndVarIntAndVarString());
}
@Test
public void testOccuringStruct1() throws Exception {
if (!shouldRunTest("OccuringStruct1")) {
return;
}
OccuringStruct1 x = new OccuringStruct1();
List<Serializable> theList = x.getVarFloatAndVarIntAndVarString();
theList.add(1.1f);
theList.add(2);
theList.add("xX");
OccuringStruct1 yOriginal = new OccuringStruct1();
theList = yOriginal.getVarFloatAndVarIntAndVarString();
theList.add(11.11f);
theList.add(22);
theList.add("yY");
Holder<OccuringStruct1> y = new Holder(yOriginal);
Holder<OccuringStruct1> z = new Holder();
OccuringStruct1 ret;
if (testDocLiteral) {
ret = docClient.testOccuringStruct1(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testOccuringStruct1(x, y, z);
} else {
ret = rpcClient.testOccuringStruct1(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testOccuringStruct1(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testOccuringStruct1(): Incorrect value for out param",
equals(yOriginal, z.value));
assertTrue("testOccuringStruct1(): Incorrect return value",
equals(x, ret));
}
}
//org.apache.type_test.types3.OccuringStruct2;
protected boolean equals(OccuringStruct2 x, OccuringStruct2 y) {
if (Float.compare(x.getVarFloat(), y.getVarFloat()) != 0) {
return false;
}
List<Serializable> xList = x.getVarIntAndVarString();
List<Serializable> yList = y.getVarIntAndVarString();
int size = xList.size();
if (size != yList.size()) {
return false;
}
for (int i = 0; i < size; i++) {
if (xList.get(i) instanceof Integer && yList.get(i) instanceof Integer) {
Integer ix = (Integer)xList.get(i);
Integer iy = (Integer)yList.get(i);
if (iy.compareTo(ix) != 0) {
return false;
}
} else if (xList.get(i) instanceof String && yList.get(i) instanceof String) {
String sx = (String)xList.get(i);
String sy = (String)yList.get(i);
if (!sx.equals(sy)) {
return false;
}
} else {
return false;
}
}
return true;
}
@Test
public void testOccuringStruct2() throws Exception {
if (!shouldRunTest("OccuringStruct2")) {
return;
}
OccuringStruct2 x = new OccuringStruct2();
x.setVarFloat(1.14f);
List<Serializable> theList = x.getVarIntAndVarString();
theList.add(0);
theList.add("x1");
theList.add(1);
theList.add("x2");
OccuringStruct2 yOriginal = new OccuringStruct2();
yOriginal.setVarFloat(3.14f);
theList = yOriginal.getVarIntAndVarString();
theList.add(42);
theList.add("the answer");
theList.add(6);
theList.add("hammer");
theList.add(2);
theList.add("anvil");
Holder<OccuringStruct2> y = new Holder(yOriginal);
Holder<OccuringStruct2> z = new Holder();
OccuringStruct2 ret;
if (testDocLiteral) {
ret = docClient.testOccuringStruct2(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testOccuringStruct2(x, y, z);
} else {
ret = rpcClient.testOccuringStruct2(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testOccuringStruct2(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testOccuringStruct2(): Incorrect value for out param",
equals(yOriginal, z.value));
assertTrue("testOccuringStruct2(): Incorrect return value",
equals(x, ret));
}
}
//org.apache.type_test.types3.OccuringChoice;
protected boolean equals(OccuringChoice x, OccuringChoice y) {
if (!equalsNilable(x.getVarAttrib(), y.getVarAttrib())) {
return false;
}
return equalsFloatIntStringList(x.getVarFloatOrVarIntOrVarString(),
y.getVarFloatOrVarIntOrVarString());
}
@Test
public void testOccuringChoice() throws Exception {
if (!shouldRunTest("OccuringChoice")) {
return;
}
OccuringChoice x = new OccuringChoice();
List<Serializable> theList = x.getVarFloatOrVarIntOrVarString();
theList.add(0);
theList.add(1.14f);
theList.add("x1");
theList.add(1);
theList.add(11.14f);
x.setVarAttrib("x_attr");
OccuringChoice yOriginal = new OccuringChoice();
theList = yOriginal.getVarFloatOrVarIntOrVarString();
theList.add(3.14f);
theList.add("y");
theList.add(42);
yOriginal.setVarAttrib("y_attr");
Holder<OccuringChoice> y = new Holder(yOriginal);
Holder<OccuringChoice> z = new Holder();
OccuringChoice ret;
if (testDocLiteral) {
ret = docClient.testOccuringChoice(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testOccuringChoice(x, y, z);
} else {
ret = rpcClient.testOccuringChoice(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testOccuringChoice(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testOccuringChoice(): Incorrect value for out param",
equals(yOriginal, z.value));
assertTrue("testOccuringChoice(): Incorrect return value",
equals(x, ret));
}
theList.add(52);
theList.add(4.14f);
y = new Holder<OccuringChoice>(yOriginal);
z = new Holder<OccuringChoice>();
if (testDocLiteral) {
ret = docClient.testOccuringChoice(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testOccuringChoice(x, y, z);
} else {
ret = rpcClient.testOccuringChoice(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testOccuringChoice(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testOccuringChoice(): Incorrect value for out param",
equals(yOriginal, z.value));
assertTrue("testOccuringChoice(): Incorrect return value",
equals(x, ret));
}
}
//org.apache.type_test.types3.OccuringChoice1;
protected boolean equals(OccuringChoice1 x, OccuringChoice1 y) {
List<Comparable> xList = x.getVarFloatOrVarInt();
List<Comparable> yList = y.getVarFloatOrVarInt();
int size = xList.size();
if (size != yList.size()) {
return false;
}
for (int i = 0; i < size; i++) {
if (xList.get(i) instanceof Integer && yList.get(i) instanceof Integer) {
Integer xi = (Integer)xList.get(i);
Integer yi = (Integer)yList.get(i);
if (xi.compareTo(yi) != 0) {
return false;
}
}
if (xList.get(i) instanceof Float && yList.get(i) instanceof Float) {
Float xf = (Float)xList.get(i);
Float yf = (Float)yList.get(i);
if (xf.compareTo(yf) != 0) {
return false;
}
}
}
return true;
}
@Test
public void testOccuringChoice1() throws Exception {
if (!shouldRunTest("OccuringChoice1")) {
return;
}
OccuringChoice1 x = new OccuringChoice1();
List<Comparable> theList = x.getVarFloatOrVarInt();
theList.add(0);
theList.add(new Float(1.14f));
theList.add(1);
theList.add(new Float(11.14f));
// leave y empty
OccuringChoice1 yOriginal = new OccuringChoice1();
Holder<OccuringChoice1> y = new Holder(yOriginal);
Holder<OccuringChoice1> z = new Holder();
OccuringChoice1 ret;
if (testDocLiteral) {
ret = docClient.testOccuringChoice1(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testOccuringChoice1(x, y, z);
} else {
ret = rpcClient.testOccuringChoice1(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testOccuringChoice1(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testOccuringChoice1(): Incorrect value for out param",
equals(yOriginal, z.value));
assertTrue("testOccuringChoice1(): Incorrect return value",
equals(x, ret));
}
}
//org.apache.type_test.types3.OccuringChoice2;
protected boolean equals(OccuringChoice2 x, OccuringChoice2 y) {
if (x.getVarString() != null && !x.getVarString().equals(y.getVarString())) {
return false;
}
if (x.getVarInt() != null && x.getVarInt() != y.getVarInt()) {
return false;
}
return true;
}
@Test
public void testOccuringChoice2() throws Exception {
if (!shouldRunTest("OccuringChoice2")) {
return;
}
OccuringChoice2 x = new OccuringChoice2();
x.setVarString("x1");
OccuringChoice2 yOriginal = new OccuringChoice2();
yOriginal.setVarString("y1");
Holder<OccuringChoice2> y = new Holder(yOriginal);
Holder<OccuringChoice2> z = new Holder();
OccuringChoice2 ret;
if (testDocLiteral) {
ret = docClient.testOccuringChoice2(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testOccuringChoice2(x, y, z);
} else {
ret = rpcClient.testOccuringChoice2(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testOccuringChoice2(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testOccuringChoice2(): Incorrect value for out param",
equals(yOriginal, z.value));
assertTrue("testOccuringChoice2(): Incorrect return value",
equals(x, ret));
}
x = new OccuringChoice2();
yOriginal = new OccuringChoice2();
yOriginal.setVarString("y1");
y = new Holder<OccuringChoice2>(yOriginal);
z = new Holder<OccuringChoice2>();
if (testDocLiteral) {
ret = docClient.testOccuringChoice2(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testOccuringChoice2(x, y, z);
} else {
ret = rpcClient.testOccuringChoice2(x, y, z);
}
if (!perfTestOnly) {
assertTrue("testOccuringChoice2(): Incorrect value for inout param",
equals(x, y.value));
assertTrue("testOccuringChoice2(): Incorrect value for out param",
equals(yOriginal, z.value));
assertTrue("testOccuringChoice2(): Incorrect return value",
equals(x, ret));
}
}
@Test
public void testAnonEnumList() throws Exception {
if (!shouldRunTest("AnonEnumList")) {
return;
}
if (testDocLiteral || testXMLBinding) {
List<Short> x = Arrays.asList((short)10, (short)100);
List<Short> yOrig = Arrays.asList((short)1000, (short)10);
Holder<List y = new Holder>(yOrig);
Holder<List z = new Holder>();
List<Short> ret = testDocLiteral ? docClient.testAnonEnumList(x, y, z) : xmlClient
.testAnonEnumList(x, y, z);
if (!perfTestOnly) {
assertTrue("testAnonEnumList(): Incorrect value for inout param", x.equals(y.value));
assertTrue("testAnonEnumList(): Incorrect value for out param", yOrig.equals(z.value));
assertTrue("testAnonEnumList(): Incorrect return value", x.equals(ret));
}
} else {
Short[] x = {(short)10, (short)100};
Short[] yOrig = {(short)1000, (short)10};
Holder<Short[]> y = new Holder(yOrig);
Holder<Short[]> z = new Holder();
Short[] ret = rpcClient.testAnonEnumList(x, y, z);
assertTrue(y.value.length == 2);
assertTrue(z.value.length == 2);
assertTrue(ret.length == 2);
if (!perfTestOnly) {
for (int i = 0; i < 2; i++) {
assertEquals("testAnonEnumList(): Incorrect value for inout param", x[i].shortValue(),
y.value[i].shortValue());
assertEquals("testAnonEnumList(): Incorrect value for out param", yOrig[i].shortValue(),
z.value[i].shortValue());
assertEquals("testAnonEnumList(): Incorrect return value", x[i].shortValue(), ret[i]
.shortValue());
}
}
}
}
@Test
public void testUnionWithAnonEnum() throws Exception {
if (!shouldRunTest("UnionWithAnonEnum")) {
return;
}
String x = "5";
String yOrig = "n/a";
Holder<String> y = new Holder(yOrig);
Holder<String> z = new Holder();
String ret;
if (testDocLiteral) {
ret = docClient.testUnionWithAnonEnum(x, y, z);
} else if (testXMLBinding) {
ret = xmlClient.testUnionWithAnonEnum(x, y, z);
} else {
ret = rpcClient.testUnionWithAnonEnum(x, y, z);
}
assertEquals("testUnionWithAnonEnum(): Incorrect value for inout param", x, y.value);
assertEquals("testUnionWithAnonEnum(): Incorrect value for out param", yOrig, z.value);
assertEquals("testUnionWithAnonEnum(): Incorrect return value", x, ret);
}
}
Other Apache CXF examples (source code examples)
Here is a short list of links related to this Apache CXF AbstractTypeTestClient3.java source code file:
|
The search page
Other Apache CXF source code examples at this package level
Click here to learn more about this project
