org.apache.cxf.systest.type_test

Class TypeTestImpl

java.lang.Object

org.apache.cxf.systest.type_test.TypeTestImpl

public class TypeTestImpl
extends Object

org.apache.cxf.systest.type_test.TypeTestImpl

Constructor Summary

Constructors

Constructor and Description
TypeTestImpl()

Method Summary

Modifier and Type	Method and Description
List<Short>	testAnonEnumList(List<Short> x, Holder<List<Short>> y, Holder<List<Short>> z)
Short[]	testAnonEnumList(Short[] x, Holder<Short[]> y, Holder<Short[]> z)
AnonTypeElement	testAnonTypeElement(AnonTypeElement x, Holder<AnonTypeElement> y, Holder<AnonTypeElement> z)
List<String>	testAnonUnionList(List<String> x, Holder<List<String>> y, Holder<List<String>> z)
String[]	testAnonUnionList(String[] x, Holder<String[]> y, Holder<String[]> z)
AnonymousStruct	testAnonymousStruct(AnonymousStruct x, Holder<AnonymousStruct> y, Holder<AnonymousStruct> z)
AnonymousType	testAnonymousType(AnonymousType x, Holder<AnonymousType> y, Holder<AnonymousType> z)
String	testAnyURI(String x, Holder<String> y, Holder<String> z)
AnyURIEnum	testAnyURIEnum(AnyURIEnum x, Holder<AnyURIEnum> y, Holder<AnyURIEnum> z)
String	testAnyURIRestriction(String x, Holder<String> y, Holder<String> z)
byte[]	testBase64Binary(byte[] x, Holder<byte[]> y, Holder<byte[]> z)
byte[]	testBase64BinaryRestriction(byte[] x, Holder<byte[]> y, Holder<byte[]> z)
boolean	testBoolean(boolean x, Holder<Boolean> y, Holder<Boolean> z)
BoundedArray	testBoundedArray(BoundedArray x, Holder<BoundedArray> y, Holder<BoundedArray> z)
byte	testByte(byte x, Holder<Byte> y, Holder<Byte> z)
ChoiceArray	testChoiceArray(ChoiceArray x, Holder<ChoiceArray> y, Holder<ChoiceArray> z)
ChoiceOfChoice	testChoiceOfChoice(ChoiceOfChoice x, Holder<ChoiceOfChoice> y, Holder<ChoiceOfChoice> z)
ChoiceOfSeq	testChoiceOfSeq(ChoiceOfSeq x, Holder<ChoiceOfSeq> y, Holder<ChoiceOfSeq> z)
ChoiceWithAnyAttribute	testChoiceWithAnyAttribute(ChoiceWithAnyAttribute x, Holder<ChoiceWithAnyAttribute> y, Holder<ChoiceWithAnyAttribute> z)
ChoiceWithBinary	testChoiceWithBinary(ChoiceWithBinary x, Holder<ChoiceWithBinary> y, Holder<ChoiceWithBinary> z)
ChoiceWithGroupChoice	testChoiceWithGroupChoice(ChoiceWithGroupChoice x, Holder<ChoiceWithGroupChoice> y, Holder<ChoiceWithGroupChoice> z)
ChoiceWithGroups	testChoiceWithGroups(ChoiceWithGroups x, Holder<ChoiceWithGroups> y, Holder<ChoiceWithGroups> z)
ChoiceWithGroupSeq	testChoiceWithGroupSeq(ChoiceWithGroupSeq x, Holder<ChoiceWithGroupSeq> y, Holder<ChoiceWithGroupSeq> z)
ChoiceWithSubstitutionGroup	testChoiceWithSubstitutionGroup(ChoiceWithSubstitutionGroup x, Holder<ChoiceWithSubstitutionGroup> y, Holder<ChoiceWithSubstitutionGroup> z)
ChoiceWithSubstitutionGroupAbstract	testChoiceWithSubstitutionGroupAbstract(ChoiceWithSubstitutionGroupAbstract x, Holder<ChoiceWithSubstitutionGroupAbstract> y, Holder<ChoiceWithSubstitutionGroupAbstract> z)
ChoiceWithSubstitutionGroupNil	testChoiceWithSubstitutionGroupNil(ChoiceWithSubstitutionGroupNil x, Holder<ChoiceWithSubstitutionGroupNil> y, Holder<ChoiceWithSubstitutionGroupNil> z)
ColourEnum	testColourEnum(ColourEnum x, Holder<ColourEnum> y, Holder<ColourEnum> z)
ComplexRestriction	testComplexRestriction(ComplexRestriction x, Holder<ComplexRestriction> y, Holder<ComplexRestriction> z)
ComplexRestriction2	testComplexRestriction2(ComplexRestriction2 x, Holder<ComplexRestriction2> y, Holder<ComplexRestriction2> z)
ComplexRestriction3	testComplexRestriction3(ComplexRestriction3 x, Holder<ComplexRestriction3> y, Holder<ComplexRestriction3> z)
ComplexRestriction4	testComplexRestriction4(ComplexRestriction4 x, Holder<ComplexRestriction4> y, Holder<ComplexRestriction4> z)
ComplexRestriction5	testComplexRestriction5(ComplexRestriction5 x, Holder<ComplexRestriction5> y, Holder<ComplexRestriction5> z)
ComplexTypeWithAttributeGroup	testComplexTypeWithAttributeGroup(ComplexTypeWithAttributeGroup x, Holder<ComplexTypeWithAttributeGroup> y, Holder<ComplexTypeWithAttributeGroup> z)
ComplexTypeWithAttributeGroup1	testComplexTypeWithAttributeGroup1(ComplexTypeWithAttributeGroup1 x, Holder<ComplexTypeWithAttributeGroup1> y, Holder<ComplexTypeWithAttributeGroup1> z)
ComplexTypeWithAttributes	testComplexTypeWithAttributes(ComplexTypeWithAttributes x, Holder<ComplexTypeWithAttributes> y, Holder<ComplexTypeWithAttributes> z)
CompoundArray	testCompoundArray(CompoundArray x, Holder<CompoundArray> y, Holder<CompoundArray> z)
XMLGregorianCalendar	testDate(XMLGregorianCalendar x, Holder<XMLGregorianCalendar> y, Holder<XMLGregorianCalendar> z)
XMLGregorianCalendar	testDateTime(XMLGregorianCalendar x, Holder<XMLGregorianCalendar> y, Holder<XMLGregorianCalendar> z)
BigDecimal	testDecimal(BigDecimal x, Holder<BigDecimal> y, Holder<BigDecimal> z)
DecimalEnum	testDecimalEnum(DecimalEnum x, Holder<DecimalEnum> y, Holder<DecimalEnum> z)
DerivedChoiceBaseArray	testDerivedChoiceBaseArray(DerivedChoiceBaseArray x, Holder<DerivedChoiceBaseArray> y, Holder<DerivedChoiceBaseArray> z)
DerivedChoiceBaseChoice	testDerivedChoiceBaseChoice(DerivedChoiceBaseChoice x, Holder<DerivedChoiceBaseChoice> y, Holder<DerivedChoiceBaseChoice> z)
DerivedChoiceBaseStruct	testDerivedChoiceBaseStruct(DerivedChoiceBaseStruct x, Holder<DerivedChoiceBaseStruct> y, Holder<DerivedChoiceBaseStruct> z)
DerivedEmptyBaseEmptyAll	testDerivedEmptyBaseEmptyAll(DerivedEmptyBaseEmptyAll x, Holder<DerivedEmptyBaseEmptyAll> y, Holder<DerivedEmptyBaseEmptyAll> z)
DerivedEmptyBaseEmptyChoice	testDerivedEmptyBaseEmptyChoice(DerivedEmptyBaseEmptyChoice x, Holder<DerivedEmptyBaseEmptyChoice> y, Holder<DerivedEmptyBaseEmptyChoice> z)
DerivedNoContent	testDerivedNoContent(DerivedNoContent x, Holder<DerivedNoContent> y, Holder<DerivedNoContent> z)
DerivedStructBaseChoice	testDerivedStructBaseChoice(DerivedStructBaseChoice x, Holder<DerivedStructBaseChoice> y, Holder<DerivedStructBaseChoice> z)
DerivedStructBaseEmpty	testDerivedStructBaseEmpty(DerivedStructBaseEmpty x, Holder<DerivedStructBaseEmpty> y, Holder<DerivedStructBaseEmpty> z)
DerivedStructBaseStruct	testDerivedStructBaseStruct(DerivedStructBaseStruct x, Holder<DerivedStructBaseStruct> y, Holder<DerivedStructBaseStruct> z)
Document	testDocument(Document x, Holder<Document> y, Holder<Document> z)
double	testDouble(double x, Holder<Double> y, Holder<Double> z)
Duration	testDuration(Duration x, Holder<Duration> y, Holder<Duration> z)
EmptyAll	testEmptyAll(EmptyAll x, Holder<EmptyAll> y, Holder<EmptyAll> z)
EmptyChoice	testEmptyChoice(EmptyChoice x, Holder<EmptyChoice> y, Holder<EmptyChoice> z)
EmptyStruct	testEmptyStruct(EmptyStruct x, Holder<EmptyStruct> y, Holder<EmptyStruct> z)
ExtBase64Binary	testExtBase64Binary(ExtBase64Binary x, Holder<ExtBase64Binary> y, Holder<ExtBase64Binary> z)
ExtColourEnum	testExtColourEnum(ExtColourEnum x, Holder<ExtColourEnum> y, Holder<ExtColourEnum> z)
ExtendsSimpleContent	testExtendsSimpleContent(ExtendsSimpleContent x, Holder<ExtendsSimpleContent> y, Holder<ExtendsSimpleContent> z)
ExtendsSimpleType	testExtendsSimpleType(ExtendsSimpleType x, Holder<ExtendsSimpleType> y, Holder<ExtendsSimpleType> z)
FixedArray	testFixedArray(FixedArray x, Holder<FixedArray> y, Holder<FixedArray> z)
float	testFloat(float x, Holder<Float> y, Holder<Float> z)
XMLGregorianCalendar	testGDay(XMLGregorianCalendar x, Holder<XMLGregorianCalendar> y, Holder<XMLGregorianCalendar> z)
XMLGregorianCalendar	testGMonth(XMLGregorianCalendar x, Holder<XMLGregorianCalendar> y, Holder<XMLGregorianCalendar> z)
XMLGregorianCalendar	testGMonthDay(XMLGregorianCalendar x, Holder<XMLGregorianCalendar> y, Holder<XMLGregorianCalendar> z)
GroupDirectlyInComplexType	testGroupDirectlyInComplexType(GroupDirectlyInComplexType x, Holder<GroupDirectlyInComplexType> y, Holder<GroupDirectlyInComplexType> z)
XMLGregorianCalendar	testGYear(XMLGregorianCalendar x, Holder<XMLGregorianCalendar> y, Holder<XMLGregorianCalendar> z)
XMLGregorianCalendar	testGYearMonth(XMLGregorianCalendar x, Holder<XMLGregorianCalendar> y, Holder<XMLGregorianCalendar> z)
byte[]	testHexBinary(byte[] x, Holder<byte[]> y, Holder<byte[]> z)
byte[]	testHexBinaryRestriction(byte[] x, Holder<byte[]> y, Holder<byte[]> z)
IDTypeAttribute	testIDTypeAttribute(IDTypeAttribute x, Holder<IDTypeAttribute> y, Holder<IDTypeAttribute> z)
int	testInt(int x, Holder<Integer> y, Holder<Integer> z)
BigInteger	testInteger(BigInteger x, Holder<BigInteger> y, Holder<BigInteger> z)
String	testLanguage(String x, Holder<String> y, Holder<String> z)
long	testLong(long x, Holder<Long> y, Holder<Long> z)
MixedArray	testMixedArray(MixedArray x, Holder<MixedArray> y, Holder<MixedArray> z)
MRecSeqA	testMRecSeqA(MRecSeqA x, Holder<MRecSeqA> y, Holder<MRecSeqA> z)
MRecSeqC	testMRecSeqC(MRecSeqC x, Holder<MRecSeqC> y, Holder<MRecSeqC> z)
MultipleOccursSequenceInSequence	testMultipleOccursSequenceInSequence(MultipleOccursSequenceInSequence x, Holder<MultipleOccursSequenceInSequence> y, Holder<MultipleOccursSequenceInSequence> z)
String	testName(String x, Holder<String> y, Holder<String> z)
String	testNCName(String x, Holder<String> y, Holder<String> z)
BigInteger	testNegativeInteger(BigInteger x, Holder<BigInteger> y, Holder<BigInteger> z)
NestedArray	testNestedArray(NestedArray x, Holder<NestedArray> y, Holder<NestedArray> z)
NestedStruct	testNestedStruct(NestedStruct x, Holder<NestedStruct> y, Holder<NestedStruct> z)
String	testNillableString(String x, Holder<String> y, Holder<String> z)
SimpleStruct	testNillableStruct(SimpleStruct x, Holder<SimpleStruct> y, Holder<SimpleStruct> z)
String	testNMTOKEN(String x, Holder<String> y, Holder<String> z)
NMTokenEnum	testNMTokenEnum(NMTokenEnum x, Holder<NMTokenEnum> y, Holder<NMTokenEnum> z)
List<String>	testNMTOKENS(List<String> x, Holder<List<String>> y, Holder<List<String>> z)
String[]	testNMTOKENS(String[] x, Holder<String[]> y, Holder<String[]> z)
BigInteger	testNonNegativeInteger(BigInteger x, Holder<BigInteger> y, Holder<BigInteger> z)
BigInteger	testNonPositiveInteger(BigInteger x, Holder<BigInteger> y, Holder<BigInteger> z)
String	testNormalizedString(String x, Holder<String> y, Holder<String> z)
NumberEnum	testNumberEnum(NumberEnum x, Holder<NumberEnum> y, Holder<NumberEnum> z)
Integer[]	testNumberList(Integer[] x, Holder<Integer[]> y, Holder<Integer[]> z)
List<Integer>	testNumberList(List<Integer> x, Holder<List<Integer>> y, Holder<List<Integer>> z)
OccuringAll	testOccuringAll(OccuringAll x, Holder<OccuringAll> y, Holder<OccuringAll> z)
OccuringChoice	testOccuringChoice(OccuringChoice x, Holder<OccuringChoice> y, Holder<OccuringChoice> z)
OccuringChoice1	testOccuringChoice1(OccuringChoice1 x, Holder<OccuringChoice1> y, Holder<OccuringChoice1> z)
OccuringChoice2	testOccuringChoice2(OccuringChoice2 x, Holder<OccuringChoice2> y, Holder<OccuringChoice2> z)
OccuringChoiceWithAnyAttribute	testOccuringChoiceWithAnyAttribute(OccuringChoiceWithAnyAttribute x, Holder<OccuringChoiceWithAnyAttribute> y, Holder<OccuringChoiceWithAnyAttribute> z)
OccuringStruct	testOccuringStruct(OccuringStruct x, Holder<OccuringStruct> y, Holder<OccuringStruct> z)
OccuringStruct1	testOccuringStruct1(OccuringStruct1 x, Holder<OccuringStruct1> y, Holder<OccuringStruct1> z)
OccuringStruct2	testOccuringStruct2(OccuringStruct2 x, Holder<OccuringStruct2> y, Holder<OccuringStruct2> z)
OccuringStructWithAnyAttribute	testOccuringStructWithAnyAttribute(OccuringStructWithAnyAttribute x, Holder<OccuringStructWithAnyAttribute> y, Holder<OccuringStructWithAnyAttribute> z)
void	testOneway(String x, String y)
BigInteger	testPositiveInteger(BigInteger x, Holder<BigInteger> y, Holder<BigInteger> z)
QName	testQName(QName x, Holder<QName> y, Holder<QName> z)
List<QName>	testQNameList(List<QName> x, Holder<List<QName>> y, Holder<List<QName>> z)
QName[]	testQNameList(QName[] x, Holder<QName[]> y, Holder<QName[]> z)
RecElType	testRecElType(RecElType x, Holder<RecElType> y, Holder<RecElType> z)
RecOuterType	testRecOuterType(RecOuterType x, Holder<RecOuterType> y, Holder<RecOuterType> z)
RecSeqB6918	testRecSeqB6918(RecSeqB6918 x, Holder<RecSeqB6918> y, Holder<RecSeqB6918> z)
RecursiveStruct	testRecursiveStruct(RecursiveStruct x, Holder<RecursiveStruct> y, Holder<RecursiveStruct> z)
RecursiveStructArray	testRecursiveStructArray(RecursiveStructArray x, Holder<RecursiveStructArray> y, Holder<RecursiveStructArray> z)
RecursiveUnion	testRecursiveUnion(RecursiveUnion x, Holder<RecursiveUnion> y, Holder<RecursiveUnion> z)
RecursiveUnionData	testRecursiveUnionData(RecursiveUnionData x, Holder<RecursiveUnionData> y, Holder<RecursiveUnionData> z)
RestrictedAllBaseAll	testRestrictedAllBaseAll(RestrictedAllBaseAll x, Holder<RestrictedAllBaseAll> y, Holder<RestrictedAllBaseAll> z)
RestrictedChoiceBaseChoice	testRestrictedChoiceBaseChoice(RestrictedChoiceBaseChoice x, Holder<RestrictedChoiceBaseChoice> y, Holder<RestrictedChoiceBaseChoice> z)
RestrictedStructBaseStruct	testRestrictedStructBaseStruct(RestrictedStructBaseStruct x, Holder<RestrictedStructBaseStruct> y, Holder<RestrictedStructBaseStruct> z)
SequenceWithGroupChoice	testSequenceWithGroupChoice(SequenceWithGroupChoice x, Holder<SequenceWithGroupChoice> y, Holder<SequenceWithGroupChoice> z)
SequenceWithGroups	testSequenceWithGroups(SequenceWithGroups x, Holder<SequenceWithGroups> y, Holder<SequenceWithGroups> z)
SequenceWithGroupSeq	testSequenceWithGroupSeq(SequenceWithGroupSeq x, Holder<SequenceWithGroupSeq> y, Holder<SequenceWithGroupSeq> z)
SequenceWithOccuringGroup	testSequenceWithOccuringGroup(SequenceWithOccuringGroup x, Holder<SequenceWithOccuringGroup> y, Holder<SequenceWithOccuringGroup> z)
short	testShort(short x, Holder<Short> y, Holder<Short> z)
SimpleAll	testSimpleAll(SimpleAll x, Holder<SimpleAll> y, Holder<SimpleAll> z)
SimpleChoice	testSimpleChoice(SimpleChoice x, Holder<SimpleChoice> y, Holder<SimpleChoice> z)
SimpleContent1	testSimpleContent1(SimpleContent1 x, Holder<SimpleContent1> y, Holder<SimpleContent1> z)
SimpleContent2	testSimpleContent2(SimpleContent2 x, Holder<SimpleContent2> y, Holder<SimpleContent2> z)
SimpleContent3	testSimpleContent3(SimpleContent3 x, Holder<SimpleContent3> y, Holder<SimpleContent3> z)
SimpleContentExtWithAnyAttribute	testSimpleContentExtWithAnyAttribute(SimpleContentExtWithAnyAttribute x, Holder<SimpleContentExtWithAnyAttribute> y, Holder<SimpleContentExtWithAnyAttribute> z)
List<String>	testSimpleListRestriction2(List<String> x, Holder<List<String>> y, Holder<List<String>> z)
String[]	testSimpleListRestriction2(String[] x, Holder<String[]> y, Holder<String[]> z)
String	testSimpleRestriction(String x, Holder<String> y, Holder<String> z)
String	testSimpleRestriction2(String x, Holder<String> y, Holder<String> z)
String	testSimpleRestriction3(String x, Holder<String> y, Holder<String> z)
String	testSimpleRestriction4(String x, Holder<String> y, Holder<String> z)
String	testSimpleRestriction5(String x, Holder<String> y, Holder<String> z)
String	testSimpleRestriction6(String x, Holder<String> y, Holder<String> z)
SimpleStruct	testSimpleStruct(SimpleStruct x, Holder<SimpleStruct> y, Holder<SimpleStruct> z)
String	testSimpleUnion(String x, Holder<String> y, Holder<String> z)
List<String>	testSimpleUnionList(List<String> x, Holder<List<String>> y, Holder<List<String>> z)
String[]	testSimpleUnionList(String[] x, Holder<String[]> y, Holder<String[]> z)
String	testString(String x, Holder<String> y, Holder<String> z)
StringEnum	testStringEnum(StringEnum x, Holder<StringEnum> y, Holder<StringEnum> z)
List<String>	testStringList(List<String> x, Holder<List<String>> y, Holder<List<String>> z)
String[]	testStringList(String[] x, Holder<String[]> y, Holder<String[]> z)
StructWithAny	testStructWithAny(StructWithAny x, Holder<StructWithAny> y, Holder<StructWithAny> z)
StructWithAnyArray	testStructWithAnyArray(StructWithAnyArray x, Holder<StructWithAnyArray> y, Holder<StructWithAnyArray> z)
StructWithAnyArrayLax	testStructWithAnyArrayLax(StructWithAnyArrayLax x, Holder<StructWithAnyArrayLax> y, Holder<StructWithAnyArrayLax> z)
StructWithAnyAttribute	testStructWithAnyAttribute(StructWithAnyAttribute x, Holder<StructWithAnyAttribute> y, Holder<StructWithAnyAttribute> z)
StructWithAnyStrict	testStructWithAnyStrict(StructWithAnyStrict x, Holder<StructWithAnyStrict> y, Holder<StructWithAnyStrict> z)
StructWithBinary	testStructWithBinary(StructWithBinary x, Holder<StructWithBinary> y, Holder<StructWithBinary> z)
StructWithList	testStructWithList(StructWithList x, Holder<StructWithList> y, Holder<StructWithList> z)
StructWithMultipleSubstitutionGroups	testStructWithMultipleSubstitutionGroups(StructWithMultipleSubstitutionGroups x, Holder<StructWithMultipleSubstitutionGroups> y, Holder<StructWithMultipleSubstitutionGroups> z)
StructWithNillableChoice	testStructWithNillableChoice(StructWithNillableChoice x, Holder<StructWithNillableChoice> y, Holder<StructWithNillableChoice> z)
StructWithNillables	testStructWithNillables(StructWithNillables x, Holder<StructWithNillables> y, Holder<StructWithNillables> z)
StructWithNillableStruct	testStructWithNillableStruct(StructWithNillableStruct x, Holder<StructWithNillableStruct> y, Holder<StructWithNillableStruct> z)
StructWithOccuringChoice	testStructWithOccuringChoice(StructWithOccuringChoice x, Holder<StructWithOccuringChoice> y, Holder<StructWithOccuringChoice> z)
StructWithOccuringStruct	testStructWithOccuringStruct(StructWithOccuringStruct x, Holder<StructWithOccuringStruct> y, Holder<StructWithOccuringStruct> z)
StructWithOptionals	testStructWithOptionals(StructWithOptionals x, Holder<StructWithOptionals> y, Holder<StructWithOptionals> z)
StructWithSubstitutionGroup	testStructWithSubstitutionGroup(StructWithSubstitutionGroup x, Holder<StructWithSubstitutionGroup> y, Holder<StructWithSubstitutionGroup> z)
StructWithSubstitutionGroupAbstract	testStructWithSubstitutionGroupAbstract(StructWithSubstitutionGroupAbstract x, Holder<StructWithSubstitutionGroupAbstract> y, Holder<StructWithSubstitutionGroupAbstract> z)
StructWithSubstitutionGroupNil	testStructWithSubstitutionGroupNil(StructWithSubstitutionGroupNil x, Holder<StructWithSubstitutionGroupNil> y, Holder<StructWithSubstitutionGroupNil> z)
StructWithUnion	testStructWithUnion(StructWithUnion x, Holder<StructWithUnion> y, Holder<StructWithUnion> z)
XMLGregorianCalendar	testTime(XMLGregorianCalendar x, Holder<XMLGregorianCalendar> y, Holder<XMLGregorianCalendar> z)
String	testToken(String x, Holder<String> y, Holder<String> z)
UnboundedArray	testUnboundedArray(UnboundedArray x, Holder<UnboundedArray> y, Holder<UnboundedArray> z)
UnionSimpleContent	testUnionSimpleContent(UnionSimpleContent x, Holder<UnionSimpleContent> y, Holder<UnionSimpleContent> z)
String	testUnionWithAnonEnum(String x, Holder<String> y, Holder<String> z)
List<String>	testUnionWithAnonList(List<String> x, Holder<List<String>> y, Holder<List<String>> z)
String[]	testUnionWithAnonList(String[] x, Holder<String[]> y, Holder<String[]> z)
String[]	testUnionWithAnonUnion(String[] x, Holder<String[]> y, Holder<String[]> z)
List<String>	testUnionWithStringList(List<String> x, Holder<List<String>> y, Holder<List<String>> z)
String[]	testUnionWithStringList(String[] x, Holder<String[]> y, Holder<String[]> z)
List<String>	testUnionWithStringListRestriction(List<String> x, Holder<List<String>> y, Holder<List<String>> z)
String[]	testUnionWithStringListRestriction(String[] x, Holder<String[]> y, Holder<String[]> z)
String[]	testUnionWithUnion(String[] x, Holder<String[]> y, Holder<String[]> z)
String[]	testUnionWithUnionRestriction(String[] x, Holder<String[]> y, Holder<String[]> z)
short	testUnsignedByte(short x, Holder<Short> y, Holder<Short> z)
long	testUnsignedInt(long x, Holder<Long> y, Holder<Long> z)
BigInteger	testUnsignedLong(BigInteger x, Holder<BigInteger> y, Holder<BigInteger> z)
int	testUnsignedShort(int x, Holder<Integer> y, Holder<Integer> z)
void	testVoid()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

TypeTestImpl

public TypeTestImpl()

Method Detail

testVoid

public void testVoid()

testOneway

public void testOneway(String x,
                       String y)

testAnonTypeElement

public AnonTypeElement testAnonTypeElement(AnonTypeElement x,
                                           Holder<AnonTypeElement> y,
                                           Holder<AnonTypeElement> z)

testNillableString

public String testNillableString(String x,
                                 Holder<String> y,
                                 Holder<String> z)

testNillableStruct

public SimpleStruct testNillableStruct(SimpleStruct x,
                                       Holder<SimpleStruct> y,
                                       Holder<SimpleStruct> z)

testSimpleRestriction

public String testSimpleRestriction(String x,
                                    Holder<String> y,
                                    Holder<String> z)

testSimpleRestriction2

public String testSimpleRestriction2(String x,
                                     Holder<String> y,
                                     Holder<String> z)

testSimpleRestriction3

public String testSimpleRestriction3(String x,
                                     Holder<String> y,
                                     Holder<String> z)

testSimpleRestriction4

public String testSimpleRestriction4(String x,
                                     Holder<String> y,
                                     Holder<String> z)

testSimpleRestriction5

public String testSimpleRestriction5(String x,
                                     Holder<String> y,
                                     Holder<String> z)

testSimpleRestriction6

public String testSimpleRestriction6(String x,
                                     Holder<String> y,
                                     Holder<String> z)

testAnyURIRestriction

public String testAnyURIRestriction(String x,
                                    Holder<String> y,
                                    Holder<String> z)

testHexBinaryRestriction

public byte[] testHexBinaryRestriction(byte[] x,
                                       Holder<byte[]> y,
                                       Holder<byte[]> z)

testBase64BinaryRestriction

public byte[] testBase64BinaryRestriction(byte[] x,
                                          Holder<byte[]> y,
                                          Holder<byte[]> z)

testSimpleListRestriction2

public List<String> testSimpleListRestriction2(List<String> x,
                                               Holder<List<String>> y,
                                               Holder<List<String>> z)

testSimpleListRestriction2

public String[] testSimpleListRestriction2(String[] x,
                                           Holder<String[]> y,
                                           Holder<String[]> z)

testStringList

public List<String> testStringList(List<String> x,
                                   Holder<List<String>> y,
                                   Holder<List<String>> z)

testStringList

public String[] testStringList(String[] x,
                               Holder<String[]> y,
                               Holder<String[]> z)

testNumberList

public List<Integer> testNumberList(List<Integer> x,
                                    Holder<List<Integer>> y,
                                    Holder<List<Integer>> z)

testNumberList

public Integer[] testNumberList(Integer[] x,
                                Holder<Integer[]> y,
                                Holder<Integer[]> z)

testQNameList

public List<QName> testQNameList(List<QName> x,
                                 Holder<List<QName>> y,
                                 Holder<List<QName>> z)

testQNameList

public QName[] testQNameList(QName[] x,
                             Holder<QName[]> y,
                             Holder<QName[]> z)

testAnonEnumList

public List<Short> testAnonEnumList(List<Short> x,
                                    Holder<List<Short>> y,
                                    Holder<List<Short>> z)

testAnonEnumList

public Short[] testAnonEnumList(Short[] x,
                                Holder<Short[]> y,
                                Holder<Short[]> z)

testSimpleUnionList

public String[] testSimpleUnionList(String[] x,
                                    Holder<String[]> y,
                                    Holder<String[]> z)

testAnonUnionList

public String[] testAnonUnionList(String[] x,
                                  Holder<String[]> y,
                                  Holder<String[]> z)

testNMTOKENS

public String[] testNMTOKENS(String[] x,
                             Holder<String[]> y,
                             Holder<String[]> z)

testIDTypeAttribute

public IDTypeAttribute testIDTypeAttribute(IDTypeAttribute x,
                                           Holder<IDTypeAttribute> y,
                                           Holder<IDTypeAttribute> z)

testUnionWithAnonList

public String[] testUnionWithAnonList(String[] x,
                                      Holder<String[]> y,
                                      Holder<String[]> z)

testUnionWithStringList

public String[] testUnionWithStringList(String[] x,
                                        Holder<String[]> y,
                                        Holder<String[]> z)

testUnionWithStringListRestriction

public String[] testUnionWithStringListRestriction(String[] x,
                                                   Holder<String[]> y,
                                                   Holder<String[]> z)

testUnionWithAnonUnion

public String[] testUnionWithAnonUnion(String[] x,
                                       Holder<String[]> y,
                                       Holder<String[]> z)

testUnionWithUnion

public String[] testUnionWithUnion(String[] x,
                                   Holder<String[]> y,
                                   Holder<String[]> z)

testUnionWithUnionRestriction

public String[] testUnionWithUnionRestriction(String[] x,
                                              Holder<String[]> y,
                                              Holder<String[]> z)

testByte

public byte testByte(byte x,
                     Holder<Byte> y,
                     Holder<Byte> z)

testShort

public short testShort(short x,
                       Holder<Short> y,
                       Holder<Short> z)

testInt

public int testInt(int x,
                   Holder<Integer> y,
                   Holder<Integer> z)

testLong

public long testLong(long x,
                     Holder<Long> y,
                     Holder<Long> z)

testUnsignedShort

public int testUnsignedShort(int x,
                             Holder<Integer> y,
                             Holder<Integer> z)

testUnsignedInt

public long testUnsignedInt(long x,
                            Holder<Long> y,
                            Holder<Long> z)

testUnsignedLong

public BigInteger testUnsignedLong(BigInteger x,
                                   Holder<BigInteger> y,
                                   Holder<BigInteger> z)

testFloat

public float testFloat(float x,
                       Holder<Float> y,
                       Holder<Float> z)

testDouble

public double testDouble(double x,
                         Holder<Double> y,
                         Holder<Double> z)

testUnsignedByte

public short testUnsignedByte(short x,
                              Holder<Short> y,
                              Holder<Short> z)

testBoolean

public boolean testBoolean(boolean x,
                           Holder<Boolean> y,
                           Holder<Boolean> z)

testString

public String testString(String x,
                         Holder<String> y,
                         Holder<String> z)

testQName

public QName testQName(QName x,
                       Holder<QName> y,
                       Holder<QName> z)

testInteger

public BigInteger testInteger(BigInteger x,
                              Holder<BigInteger> y,
                              Holder<BigInteger> z)

testPositiveInteger

public BigInteger testPositiveInteger(BigInteger x,
                                      Holder<BigInteger> y,
                                      Holder<BigInteger> z)

testNonPositiveInteger

public BigInteger testNonPositiveInteger(BigInteger x,
                                         Holder<BigInteger> y,
                                         Holder<BigInteger> z)

testNegativeInteger

public BigInteger testNegativeInteger(BigInteger x,
                                      Holder<BigInteger> y,
                                      Holder<BigInteger> z)

testNonNegativeInteger

public BigInteger testNonNegativeInteger(BigInteger x,
                                         Holder<BigInteger> y,
                                         Holder<BigInteger> z)

testDecimal

public BigDecimal testDecimal(BigDecimal x,
                              Holder<BigDecimal> y,
                              Holder<BigDecimal> z)

testDate

public XMLGregorianCalendar testDate(XMLGregorianCalendar x,
                                     Holder<XMLGregorianCalendar> y,
                                     Holder<XMLGregorianCalendar> z)

testDateTime

public XMLGregorianCalendar testDateTime(XMLGregorianCalendar x,
                                         Holder<XMLGregorianCalendar> y,
                                         Holder<XMLGregorianCalendar> z)

testTime

public XMLGregorianCalendar testTime(XMLGregorianCalendar x,
                                     Holder<XMLGregorianCalendar> y,
                                     Holder<XMLGregorianCalendar> z)

testGYear

public XMLGregorianCalendar testGYear(XMLGregorianCalendar x,
                                      Holder<XMLGregorianCalendar> y,
                                      Holder<XMLGregorianCalendar> z)

testGYearMonth

public XMLGregorianCalendar testGYearMonth(XMLGregorianCalendar x,
                                           Holder<XMLGregorianCalendar> y,
                                           Holder<XMLGregorianCalendar> z)

testGMonth

public XMLGregorianCalendar testGMonth(XMLGregorianCalendar x,
                                       Holder<XMLGregorianCalendar> y,
                                       Holder<XMLGregorianCalendar> z)

testGMonthDay

public XMLGregorianCalendar testGMonthDay(XMLGregorianCalendar x,
                                          Holder<XMLGregorianCalendar> y,
                                          Holder<XMLGregorianCalendar> z)

testGDay

public XMLGregorianCalendar testGDay(XMLGregorianCalendar x,
                                     Holder<XMLGregorianCalendar> y,
                                     Holder<XMLGregorianCalendar> z)

testDuration

public Duration testDuration(Duration x,
                             Holder<Duration> y,
                             Holder<Duration> z)

testAnyURI

public String testAnyURI(String x,
                         Holder<String> y,
                         Holder<String> z)

testNormalizedString

public String testNormalizedString(String x,
                                   Holder<String> y,
                                   Holder<String> z)

testToken

public String testToken(String x,
                        Holder<String> y,
                        Holder<String> z)

testLanguage

public String testLanguage(String x,
                           Holder<String> y,
                           Holder<String> z)

testNMTOKEN

public String testNMTOKEN(String x,
                          Holder<String> y,
                          Holder<String> z)

testNMTOKENS

public List<String> testNMTOKENS(List<String> x,
                                 Holder<List<String>> y,
                                 Holder<List<String>> z)

testName

public String testName(String x,
                       Holder<String> y,
                       Holder<String> z)

testNCName

public String testNCName(String x,
                         Holder<String> y,
                         Holder<String> z)

testBase64Binary

public byte[] testBase64Binary(byte[] x,
                               Holder<byte[]> y,
                               Holder<byte[]> z)

testHexBinary

public byte[] testHexBinary(byte[] x,
                            Holder<byte[]> y,
                            Holder<byte[]> z)

testColourEnum

public ColourEnum testColourEnum(ColourEnum x,
                                 Holder<ColourEnum> y,
                                 Holder<ColourEnum> z)

testNumberEnum

public NumberEnum testNumberEnum(NumberEnum x,
                                 Holder<NumberEnum> y,
                                 Holder<NumberEnum> z)

testStringEnum

public StringEnum testStringEnum(StringEnum x,
                                 Holder<StringEnum> y,
                                 Holder<StringEnum> z)

testDecimalEnum

public DecimalEnum testDecimalEnum(DecimalEnum x,
                                   Holder<DecimalEnum> y,
                                   Holder<DecimalEnum> z)

testNMTokenEnum

public NMTokenEnum testNMTokenEnum(NMTokenEnum x,
                                   Holder<NMTokenEnum> y,
                                   Holder<NMTokenEnum> z)

testAnyURIEnum

public AnyURIEnum testAnyURIEnum(AnyURIEnum x,
                                 Holder<AnyURIEnum> y,
                                 Holder<AnyURIEnum> z)

testSimpleUnionList

public List<String> testSimpleUnionList(List<String> x,
                                        Holder<List<String>> y,
                                        Holder<List<String>> z)

testAnonUnionList

public List<String> testAnonUnionList(List<String> x,
                                      Holder<List<String>> y,
                                      Holder<List<String>> z)

testSimpleUnion

public String testSimpleUnion(String x,
                              Holder<String> y,
                              Holder<String> z)

testUnionWithAnonEnum

public String testUnionWithAnonEnum(String x,
                                    Holder<String> y,
                                    Holder<String> z)

testUnionWithStringList

public List<String> testUnionWithStringList(List<String> x,
                                            Holder<List<String>> y,
                                            Holder<List<String>> z)

testUnionWithStringListRestriction

public List<String> testUnionWithStringListRestriction(List<String> x,
                                                       Holder<List<String>> y,
                                                       Holder<List<String>> z)

testUnionWithAnonList

public List<String> testUnionWithAnonList(List<String> x,
                                          Holder<List<String>> y,
                                          Holder<List<String>> z)

testStructWithNillables

public StructWithNillables testStructWithNillables(StructWithNillables x,
                                                   Holder<StructWithNillables> y,
                                                   Holder<StructWithNillables> z)

testEmptyStruct

public EmptyStruct testEmptyStruct(EmptyStruct x,
                                   Holder<EmptyStruct> y,
                                   Holder<EmptyStruct> z)

testSimpleStruct

public SimpleStruct testSimpleStruct(SimpleStruct x,
                                     Holder<SimpleStruct> y,
                                     Holder<SimpleStruct> z)

testNestedStruct

public NestedStruct testNestedStruct(NestedStruct x,
                                     Holder<NestedStruct> y,
                                     Holder<NestedStruct> z)

testAnonymousStruct

public AnonymousStruct testAnonymousStruct(AnonymousStruct x,
                                           Holder<AnonymousStruct> y,
                                           Holder<AnonymousStruct> z)

testAnonymousType

public AnonymousType testAnonymousType(AnonymousType x,
                                       Holder<AnonymousType> y,
                                       Holder<AnonymousType> z)

testFixedArray

public FixedArray testFixedArray(FixedArray x,
                                 Holder<FixedArray> y,
                                 Holder<FixedArray> z)

testUnboundedArray

public UnboundedArray testUnboundedArray(UnboundedArray x,
                                         Holder<UnboundedArray> y,
                                         Holder<UnboundedArray> z)

testBoundedArray

public BoundedArray testBoundedArray(BoundedArray x,
                                     Holder<BoundedArray> y,
                                     Holder<BoundedArray> z)

testCompoundArray

public CompoundArray testCompoundArray(CompoundArray x,
                                       Holder<CompoundArray> y,
                                       Holder<CompoundArray> z)

testMixedArray

public MixedArray testMixedArray(MixedArray x,
                                 Holder<MixedArray> y,
                                 Holder<MixedArray> z)

testNestedArray

public NestedArray testNestedArray(NestedArray x,
                                   Holder<NestedArray> y,
                                   Holder<NestedArray> z)

testComplexRestriction

public ComplexRestriction testComplexRestriction(ComplexRestriction x,
                                                 Holder<ComplexRestriction> y,
                                                 Holder<ComplexRestriction> z)

testComplexRestriction2

public ComplexRestriction2 testComplexRestriction2(ComplexRestriction2 x,
                                                   Holder<ComplexRestriction2> y,
                                                   Holder<ComplexRestriction2> z)

testComplexRestriction3

public ComplexRestriction3 testComplexRestriction3(ComplexRestriction3 x,
                                                   Holder<ComplexRestriction3> y,
                                                   Holder<ComplexRestriction3> z)

testComplexRestriction4

public ComplexRestriction4 testComplexRestriction4(ComplexRestriction4 x,
                                                   Holder<ComplexRestriction4> y,
                                                   Holder<ComplexRestriction4> z)

testComplexRestriction5

public ComplexRestriction5 testComplexRestriction5(ComplexRestriction5 x,
                                                   Holder<ComplexRestriction5> y,
                                                   Holder<ComplexRestriction5> z)

testStructWithList

public StructWithList testStructWithList(StructWithList x,
                                         Holder<StructWithList> y,
                                         Holder<StructWithList> z)

testStructWithUnion

public StructWithUnion testStructWithUnion(StructWithUnion x,
                                           Holder<StructWithUnion> y,
                                           Holder<StructWithUnion> z)

testUnionSimpleContent

public UnionSimpleContent testUnionSimpleContent(UnionSimpleContent x,
                                                 Holder<UnionSimpleContent> y,
                                                 Holder<UnionSimpleContent> z)

testEmptyChoice

public EmptyChoice testEmptyChoice(EmptyChoice x,
                                   Holder<EmptyChoice> y,
                                   Holder<EmptyChoice> z)

testSimpleChoice

public SimpleChoice testSimpleChoice(SimpleChoice x,
                                     Holder<SimpleChoice> y,
                                     Holder<SimpleChoice> z)

testEmptyAll

public EmptyAll testEmptyAll(EmptyAll x,
                             Holder<EmptyAll> y,
                             Holder<EmptyAll> z)

testSimpleAll

public SimpleAll testSimpleAll(SimpleAll x,
                               Holder<SimpleAll> y,
                               Holder<SimpleAll> z)

testOccuringAll

public OccuringAll testOccuringAll(OccuringAll x,
                                   Holder<OccuringAll> y,
                                   Holder<OccuringAll> z)

testStructWithOptionals

public StructWithOptionals testStructWithOptionals(StructWithOptionals x,
                                                   Holder<StructWithOptionals> y,
                                                   Holder<StructWithOptionals> z)

testRecursiveStruct

public RecursiveStruct testRecursiveStruct(RecursiveStruct x,
                                           Holder<RecursiveStruct> y,
                                           Holder<RecursiveStruct> z)

testRecursiveStructArray

public RecursiveStructArray testRecursiveStructArray(RecursiveStructArray x,
                                                     Holder<RecursiveStructArray> y,
                                                     Holder<RecursiveStructArray> z)

testRecursiveUnion

public RecursiveUnion testRecursiveUnion(RecursiveUnion x,
                                         Holder<RecursiveUnion> y,
                                         Holder<RecursiveUnion> z)

testRecursiveUnionData

public RecursiveUnionData testRecursiveUnionData(RecursiveUnionData x,
                                                 Holder<RecursiveUnionData> y,
                                                 Holder<RecursiveUnionData> z)

testChoiceArray

public ChoiceArray testChoiceArray(ChoiceArray x,
                                   Holder<ChoiceArray> y,
                                   Holder<ChoiceArray> z)

testRecSeqB6918

public RecSeqB6918 testRecSeqB6918(RecSeqB6918 x,
                                   Holder<RecSeqB6918> y,
                                   Holder<RecSeqB6918> z)

testExtendsSimpleType

public ExtendsSimpleType testExtendsSimpleType(ExtendsSimpleType x,
                                               Holder<ExtendsSimpleType> y,
                                               Holder<ExtendsSimpleType> z)

testExtendsSimpleContent

public ExtendsSimpleContent testExtendsSimpleContent(ExtendsSimpleContent x,
                                                     Holder<ExtendsSimpleContent> y,
                                                     Holder<ExtendsSimpleContent> z)

testSimpleContent1

public SimpleContent1 testSimpleContent1(SimpleContent1 x,
                                         Holder<SimpleContent1> y,
                                         Holder<SimpleContent1> z)

testSimpleContent2

public SimpleContent2 testSimpleContent2(SimpleContent2 x,
                                         Holder<SimpleContent2> y,
                                         Holder<SimpleContent2> z)

testSimpleContent3

public SimpleContent3 testSimpleContent3(SimpleContent3 x,
                                         Holder<SimpleContent3> y,
                                         Holder<SimpleContent3> z)

testDocument

public Document testDocument(Document x,
                             Holder<Document> y,
                             Holder<Document> z)

testExtColourEnum

public ExtColourEnum testExtColourEnum(ExtColourEnum x,
                                       Holder<ExtColourEnum> y,
                                       Holder<ExtColourEnum> z)

testDerivedStructBaseStruct

public DerivedStructBaseStruct testDerivedStructBaseStruct(DerivedStructBaseStruct x,
                                                           Holder<DerivedStructBaseStruct> y,
                                                           Holder<DerivedStructBaseStruct> z)

testDerivedStructBaseChoice

public DerivedStructBaseChoice testDerivedStructBaseChoice(DerivedStructBaseChoice x,
                                                           Holder<DerivedStructBaseChoice> y,
                                                           Holder<DerivedStructBaseChoice> z)

testDerivedChoiceBaseStruct

public DerivedChoiceBaseStruct testDerivedChoiceBaseStruct(DerivedChoiceBaseStruct x,
                                                           Holder<DerivedChoiceBaseStruct> y,
                                                           Holder<DerivedChoiceBaseStruct> z)

testDerivedChoiceBaseChoice

public DerivedChoiceBaseChoice testDerivedChoiceBaseChoice(DerivedChoiceBaseChoice x,
                                                           Holder<DerivedChoiceBaseChoice> y,
                                                           Holder<DerivedChoiceBaseChoice> z)

testDerivedChoiceBaseArray

public DerivedChoiceBaseArray testDerivedChoiceBaseArray(DerivedChoiceBaseArray x,
                                                         Holder<DerivedChoiceBaseArray> y,
                                                         Holder<DerivedChoiceBaseArray> z)

testDerivedNoContent

public DerivedNoContent testDerivedNoContent(DerivedNoContent x,
                                             Holder<DerivedNoContent> y,
                                             Holder<DerivedNoContent> z)

testDerivedStructBaseEmpty

public DerivedStructBaseEmpty testDerivedStructBaseEmpty(DerivedStructBaseEmpty x,
                                                         Holder<DerivedStructBaseEmpty> y,
                                                         Holder<DerivedStructBaseEmpty> z)

testDerivedEmptyBaseEmptyAll

public DerivedEmptyBaseEmptyAll testDerivedEmptyBaseEmptyAll(DerivedEmptyBaseEmptyAll x,
                                                             Holder<DerivedEmptyBaseEmptyAll> y,
                                                             Holder<DerivedEmptyBaseEmptyAll> z)

testDerivedEmptyBaseEmptyChoice

public DerivedEmptyBaseEmptyChoice testDerivedEmptyBaseEmptyChoice(DerivedEmptyBaseEmptyChoice x,
                                                                   Holder<DerivedEmptyBaseEmptyChoice> y,
                                                                   Holder<DerivedEmptyBaseEmptyChoice> z)

testRestrictedStructBaseStruct

public RestrictedStructBaseStruct testRestrictedStructBaseStruct(RestrictedStructBaseStruct x,
                                                                 Holder<RestrictedStructBaseStruct> y,
                                                                 Holder<RestrictedStructBaseStruct> z)

testRestrictedAllBaseAll

public RestrictedAllBaseAll testRestrictedAllBaseAll(RestrictedAllBaseAll x,
                                                     Holder<RestrictedAllBaseAll> y,
                                                     Holder<RestrictedAllBaseAll> z)

testRestrictedChoiceBaseChoice

public RestrictedChoiceBaseChoice testRestrictedChoiceBaseChoice(RestrictedChoiceBaseChoice x,
                                                                 Holder<RestrictedChoiceBaseChoice> y,
                                                                 Holder<RestrictedChoiceBaseChoice> z)

testComplexTypeWithAttributeGroup

public ComplexTypeWithAttributeGroup testComplexTypeWithAttributeGroup(ComplexTypeWithAttributeGroup x,
                                                                       Holder<ComplexTypeWithAttributeGroup> y,
                                                                       Holder<ComplexTypeWithAttributeGroup> z)

testComplexTypeWithAttributeGroup1

public ComplexTypeWithAttributeGroup1 testComplexTypeWithAttributeGroup1(ComplexTypeWithAttributeGroup1 x,
                                                                         Holder<ComplexTypeWithAttributeGroup1> y,
                                                                         Holder<ComplexTypeWithAttributeGroup1> z)

testSequenceWithGroupSeq

public SequenceWithGroupSeq testSequenceWithGroupSeq(SequenceWithGroupSeq x,
                                                     Holder<SequenceWithGroupSeq> y,
                                                     Holder<SequenceWithGroupSeq> z)

testSequenceWithGroupChoice

public SequenceWithGroupChoice testSequenceWithGroupChoice(SequenceWithGroupChoice x,
                                                           Holder<SequenceWithGroupChoice> y,
                                                           Holder<SequenceWithGroupChoice> z)

testSequenceWithGroups

public SequenceWithGroups testSequenceWithGroups(SequenceWithGroups x,
                                                 Holder<SequenceWithGroups> y,
                                                 Holder<SequenceWithGroups> z)

testSequenceWithOccuringGroup

public SequenceWithOccuringGroup testSequenceWithOccuringGroup(SequenceWithOccuringGroup x,
                                                               Holder<SequenceWithOccuringGroup> y,
                                                               Holder<SequenceWithOccuringGroup> z)

testChoiceWithGroupSeq

public ChoiceWithGroupSeq testChoiceWithGroupSeq(ChoiceWithGroupSeq x,
                                                 Holder<ChoiceWithGroupSeq> y,
                                                 Holder<ChoiceWithGroupSeq> z)

testChoiceWithGroupChoice

public ChoiceWithGroupChoice testChoiceWithGroupChoice(ChoiceWithGroupChoice x,
                                                       Holder<ChoiceWithGroupChoice> y,
                                                       Holder<ChoiceWithGroupChoice> z)

testChoiceWithGroups

public ChoiceWithGroups testChoiceWithGroups(ChoiceWithGroups x,
                                             Holder<ChoiceWithGroups> y,
                                             Holder<ChoiceWithGroups> z)

testGroupDirectlyInComplexType

public GroupDirectlyInComplexType testGroupDirectlyInComplexType(GroupDirectlyInComplexType x,
                                                                 Holder<GroupDirectlyInComplexType> y,
                                                                 Holder<GroupDirectlyInComplexType> z)

testChoiceOfSeq

public ChoiceOfSeq testChoiceOfSeq(ChoiceOfSeq x,
                                   Holder<ChoiceOfSeq> y,
                                   Holder<ChoiceOfSeq> z)

testChoiceOfChoice

public ChoiceOfChoice testChoiceOfChoice(ChoiceOfChoice x,
                                         Holder<ChoiceOfChoice> y,
                                         Holder<ChoiceOfChoice> z)

testComplexTypeWithAttributes

public ComplexTypeWithAttributes testComplexTypeWithAttributes(ComplexTypeWithAttributes x,
                                                               Holder<ComplexTypeWithAttributes> y,
                                                               Holder<ComplexTypeWithAttributes> z)

testStructWithAny

public StructWithAny testStructWithAny(StructWithAny x,
                                       Holder<StructWithAny> y,
                                       Holder<StructWithAny> z)

testStructWithAnyArray

public StructWithAnyArray testStructWithAnyArray(StructWithAnyArray x,
                                                 Holder<StructWithAnyArray> y,
                                                 Holder<StructWithAnyArray> z)

testStructWithAnyStrict

public StructWithAnyStrict testStructWithAnyStrict(StructWithAnyStrict x,
                                                   Holder<StructWithAnyStrict> y,
                                                   Holder<StructWithAnyStrict> z)

testStructWithAnyArrayLax

public StructWithAnyArrayLax testStructWithAnyArrayLax(StructWithAnyArrayLax x,
                                                       Holder<StructWithAnyArrayLax> y,
                                                       Holder<StructWithAnyArrayLax> z)

testMultipleOccursSequenceInSequence

public MultipleOccursSequenceInSequence testMultipleOccursSequenceInSequence(MultipleOccursSequenceInSequence x,
                                                                             Holder<MultipleOccursSequenceInSequence> y,
                                                                             Holder<MultipleOccursSequenceInSequence> z)

testStructWithBinary

public StructWithBinary testStructWithBinary(StructWithBinary x,
                                             Holder<StructWithBinary> y,
                                             Holder<StructWithBinary> z)

testChoiceWithBinary

public ChoiceWithBinary testChoiceWithBinary(ChoiceWithBinary x,
                                             Holder<ChoiceWithBinary> y,
                                             Holder<ChoiceWithBinary> z)

testExtBase64Binary

public ExtBase64Binary testExtBase64Binary(ExtBase64Binary x,
                                           Holder<ExtBase64Binary> y,
                                           Holder<ExtBase64Binary> z)

testStructWithAnyAttribute

public StructWithAnyAttribute testStructWithAnyAttribute(StructWithAnyAttribute x,
                                                         Holder<StructWithAnyAttribute> y,
                                                         Holder<StructWithAnyAttribute> z)

testChoiceWithAnyAttribute

public ChoiceWithAnyAttribute testChoiceWithAnyAttribute(ChoiceWithAnyAttribute x,
                                                         Holder<ChoiceWithAnyAttribute> y,
                                                         Holder<ChoiceWithAnyAttribute> z)

testSimpleContentExtWithAnyAttribute

public SimpleContentExtWithAnyAttribute testSimpleContentExtWithAnyAttribute(SimpleContentExtWithAnyAttribute x,
                                                                             Holder<SimpleContentExtWithAnyAttribute> y,
                                                                             Holder<SimpleContentExtWithAnyAttribute> z)

testOccuringStructWithAnyAttribute

public OccuringStructWithAnyAttribute testOccuringStructWithAnyAttribute(OccuringStructWithAnyAttribute x,
                                                                         Holder<OccuringStructWithAnyAttribute> y,
                                                                         Holder<OccuringStructWithAnyAttribute> z)

testOccuringChoiceWithAnyAttribute

public OccuringChoiceWithAnyAttribute testOccuringChoiceWithAnyAttribute(OccuringChoiceWithAnyAttribute x,
                                                                         Holder<OccuringChoiceWithAnyAttribute> y,
                                                                         Holder<OccuringChoiceWithAnyAttribute> z)

testOccuringStruct

public OccuringStruct testOccuringStruct(OccuringStruct x,
                                         Holder<OccuringStruct> y,
                                         Holder<OccuringStruct> z)

testOccuringStruct1

public OccuringStruct1 testOccuringStruct1(OccuringStruct1 x,
                                           Holder<OccuringStruct1> y,
                                           Holder<OccuringStruct1> z)

testOccuringStruct2

public OccuringStruct2 testOccuringStruct2(OccuringStruct2 x,
                                           Holder<OccuringStruct2> y,
                                           Holder<OccuringStruct2> z)

testStructWithNillableStruct

public StructWithNillableStruct testStructWithNillableStruct(StructWithNillableStruct x,
                                                             Holder<StructWithNillableStruct> y,
                                                             Holder<StructWithNillableStruct> z)

testStructWithOccuringStruct

public StructWithOccuringStruct testStructWithOccuringStruct(StructWithOccuringStruct x,
                                                             Holder<StructWithOccuringStruct> y,
                                                             Holder<StructWithOccuringStruct> z)

testOccuringChoice

public OccuringChoice testOccuringChoice(OccuringChoice x,
                                         Holder<OccuringChoice> y,
                                         Holder<OccuringChoice> z)

testOccuringChoice1

public OccuringChoice1 testOccuringChoice1(OccuringChoice1 x,
                                           Holder<OccuringChoice1> y,
                                           Holder<OccuringChoice1> z)

testOccuringChoice2

public OccuringChoice2 testOccuringChoice2(OccuringChoice2 x,
                                           Holder<OccuringChoice2> y,
                                           Holder<OccuringChoice2> z)

testStructWithNillableChoice

public StructWithNillableChoice testStructWithNillableChoice(StructWithNillableChoice x,
                                                             Holder<StructWithNillableChoice> y,
                                                             Holder<StructWithNillableChoice> z)

testStructWithOccuringChoice

public StructWithOccuringChoice testStructWithOccuringChoice(StructWithOccuringChoice x,
                                                             Holder<StructWithOccuringChoice> y,
                                                             Holder<StructWithOccuringChoice> z)

testStructWithSubstitutionGroup

public StructWithSubstitutionGroup testStructWithSubstitutionGroup(StructWithSubstitutionGroup x,
                                                                   Holder<StructWithSubstitutionGroup> y,
                                                                   Holder<StructWithSubstitutionGroup> z)

testStructWithSubstitutionGroupAbstract

public StructWithSubstitutionGroupAbstract testStructWithSubstitutionGroupAbstract(StructWithSubstitutionGroupAbstract x,
                                                                                   Holder<StructWithSubstitutionGroupAbstract> y,
                                                                                   Holder<StructWithSubstitutionGroupAbstract> z)

testStructWithSubstitutionGroupNil

public StructWithSubstitutionGroupNil testStructWithSubstitutionGroupNil(StructWithSubstitutionGroupNil x,
                                                                         Holder<StructWithSubstitutionGroupNil> y,
                                                                         Holder<StructWithSubstitutionGroupNil> z)

testStructWithMultipleSubstitutionGroups

public StructWithMultipleSubstitutionGroups testStructWithMultipleSubstitutionGroups(StructWithMultipleSubstitutionGroups x,
                                                                                     Holder<StructWithMultipleSubstitutionGroups> y,
                                                                                     Holder<StructWithMultipleSubstitutionGroups> z)

testChoiceWithSubstitutionGroup

public ChoiceWithSubstitutionGroup testChoiceWithSubstitutionGroup(ChoiceWithSubstitutionGroup x,
                                                                   Holder<ChoiceWithSubstitutionGroup> y,
                                                                   Holder<ChoiceWithSubstitutionGroup> z)

testChoiceWithSubstitutionGroupAbstract

public ChoiceWithSubstitutionGroupAbstract testChoiceWithSubstitutionGroupAbstract(ChoiceWithSubstitutionGroupAbstract x,
                                                                                   Holder<ChoiceWithSubstitutionGroupAbstract> y,
                                                                                   Holder<ChoiceWithSubstitutionGroupAbstract> z)

testChoiceWithSubstitutionGroupNil

public ChoiceWithSubstitutionGroupNil testChoiceWithSubstitutionGroupNil(ChoiceWithSubstitutionGroupNil x,
                                                                         Holder<ChoiceWithSubstitutionGroupNil> y,
                                                                         Holder<ChoiceWithSubstitutionGroupNil> z)

testRecElType

public RecElType testRecElType(RecElType x,
                               Holder<RecElType> y,
                               Holder<RecElType> z)

testRecOuterType

public RecOuterType testRecOuterType(RecOuterType x,
                                     Holder<RecOuterType> y,
                                     Holder<RecOuterType> z)

testMRecSeqA

public MRecSeqA testMRecSeqA(MRecSeqA x,
                             Holder<MRecSeqA> y,
                             Holder<MRecSeqA> z)

testMRecSeqC

public MRecSeqC testMRecSeqC(MRecSeqC x,
                             Holder<MRecSeqC> y,
                             Holder<MRecSeqC> z)