text:
/**
 * TypeTestServiceTestCase.java
 *
 * This file was auto-generated from WSDL
 * by the Apache Axis Wsdl2java emitter.
 */

package test.wsdl.types;

import junit.framework.AssertionFailedError;
import junit.framework.TestCase;
import org.apache.axis.holders.DayHolder;
import org.apache.axis.holders.MonthDayHolder;
import org.apache.axis.holders.MonthHolder;
import org.apache.axis.holders.NegativeIntegerHolder;
import org.apache.axis.holders.NonNegativeIntegerHolder;
import org.apache.axis.holders.NonPositiveIntegerHolder;
import org.apache.axis.holders.PositiveIntegerHolder;
import org.apache.axis.holders.TimeHolder;
import org.apache.axis.holders.URIHolder;
import org.apache.axis.holders.UnsignedByteHolder;
import org.apache.axis.holders.UnsignedIntHolder;
import org.apache.axis.holders.UnsignedLongHolder;
import org.apache.axis.holders.UnsignedShortHolder;
import org.apache.axis.holders.YearHolder;
import org.apache.axis.holders.YearMonthHolder;
import org.apache.axis.types.Day;
import org.apache.axis.types.Month;
import org.apache.axis.types.MonthDay;
import org.apache.axis.types.NegativeInteger;
import org.apache.axis.types.NonNegativeInteger;
import org.apache.axis.types.NonPositiveInteger;
import org.apache.axis.types.PositiveInteger;
import org.apache.axis.types.Time;
import org.apache.axis.types.URI;
import org.apache.axis.types.UnsignedByte;
import org.apache.axis.types.UnsignedInt;
import org.apache.axis.types.UnsignedLong;
import org.apache.axis.types.UnsignedShort;
import org.apache.axis.types.Year;
import org.apache.axis.types.YearMonth;
import test.wsdl.types.comprehensive_service.TypeTest;

import javax.xml.namespace.QName;
import javax.xml.rpc.Service;
import javax.xml.rpc.ServiceException;
import javax.xml.rpc.ServiceFactory;
import javax.xml.rpc.Stub;
import javax.xml.rpc.holders.BigDecimalHolder;
import javax.xml.rpc.holders.BigIntegerHolder;
import javax.xml.rpc.holders.BooleanHolder;
import javax.xml.rpc.holders.BooleanWrapperHolder;
import javax.xml.rpc.holders.ByteArrayHolder;
import javax.xml.rpc.holders.ByteHolder;
import javax.xml.rpc.holders.CalendarHolder;
import javax.xml.rpc.holders.DoubleHolder;
import javax.xml.rpc.holders.DoubleWrapperHolder;
import javax.xml.rpc.holders.FloatHolder;
import javax.xml.rpc.holders.FloatWrapperHolder;
import javax.xml.rpc.holders.IntHolder;
import javax.xml.rpc.holders.IntegerWrapperHolder;
import javax.xml.rpc.holders.LongHolder;
import javax.xml.rpc.holders.QNameHolder;
import javax.xml.rpc.holders.ShortHolder;
import javax.xml.rpc.holders.ShortWrapperHolder;
import javax.xml.rpc.holders.StringHolder;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.MalformedURLException;
import java.net.URL;
import java.rmi.RemoteException;
import java.util.Calendar;

public class DynamicProxyTestCase extends TestCase {
    public DynamicProxyTestCase(String name) {
        super(name);
    }

    private TypeTest getProxyWithWSDL() {
        try {
            Service service = ServiceFactory.newInstance().createService(
                new URL("file", "", "test/wsdl/types/ComprehensiveTypes.wsdl"),
                new QName("urn:comprehensive-service.types.wsdl.test",
                        "TypeTestService"));
            return (TypeTest) service.getPort(
                new QName("", "TypeTest"), TypeTest.class);
        }
        catch (MalformedURLException mue) {
            throw new AssertionFailedError(
                    "MalformedURLException caught: " + mue);
        }
        catch (ServiceException jre) {
            throw new AssertionFailedError("ServiceException caught: " + jre);
        }
    } // getProxyWithWSDL

    private TypeTest getProxy() {
        try {
            Service service = ServiceFactory.newInstance().createService(null);
            Stub binding = (Stub) service.getPort(TypeTest.class);
            binding._setProperty(Stub.ENDPOINT_ADDRESS_PROPERTY,
                    "http://localhost:8080/axis/services/TypeTest");
            throw new AssertionFailedError("Should not get a binding");
        }
        catch (ServiceException jre) {
            return null;
        }
    } // getProxy

    private void allPrimitivesIn(TypeTest binding) {
        assertTrue("binding is null", binding != null);
        try {

            binding.allPrimitivesIn(
                    new String(),
                    new BigInteger("0"),
                    0,
                    0,
                    (short)0,
                    new BigDecimal(0),
                    0,
                    0,
                    true,
                    (byte)0,
                    new QName("http://double-double", "toil-and-trouble"),
                    Calendar.getInstance(),
                    new byte[0],
                    new byte[0],
                    new String(),
                    new Boolean(false),
                    new Float(0),
                    new Double(0),
                    new BigDecimal(0),
                    new Integer(0),
                    new Short((short)0),
                    new byte[0],
                    new Time("12:01:30.150Z"),
                    new UnsignedLong(0),
                    new UnsignedInt(0),
                    new UnsignedShort(0),
                    new UnsignedByte(0),
                    new NonNegativeInteger("0"),
                    new PositiveInteger("1"),
                    new NonPositiveInteger("0"),
                    new NegativeInteger("-1"),
                    new URI("urn:this-is-a-test"),
                    new Year(1995),
                    new Month(7),
                    new Day(13),
                    new YearMonth(2002, 8),
                    new MonthDay(8, 26)
                    );
        }
        catch (RemoteException re) {
            re.printStackTrace();
            throw new AssertionFailedError("Remote Exception caught: " + re);
        }
        catch (Exception e) {
            // possibly thrown from Unsigned constructors
            // wont happen since we know the value are good!
        }

    } // allPrimitivesIn

    public void test1TypeTestAllPrimitivesIn() {
        TypeTest binding = getProxyWithWSDL();
        allPrimitivesIn(binding);
        binding = getProxy();
        assertTrue(binding == null);
    } // test2TypeTestAllPrimitivesInout

    private void allPrimitivesInout(TypeTest binding) {
        assertTrue("binding is null", binding != null);
        try {

            binding.allPrimitivesInout(
                    new StringHolder(new String()),
                    new BigIntegerHolder(new BigInteger("0")),
                    new IntHolder(0),
                    new LongHolder(0),
                    new ShortHolder((short)0),
                    new BigDecimalHolder(new BigDecimal(0)),
                    new FloatHolder(0),
                    new DoubleHolder(0),
                    new BooleanHolder(true),
                    new ByteHolder((byte)0),
                    new QNameHolder(new QName("http://double-double",
                            "toil-and-trouble")),
                    new CalendarHolder(Calendar.getInstance()),
                    new ByteArrayHolder(new byte[0]),
                    new ByteArrayHolder(new byte[0]),
                    new StringHolder(new String()),
                    new BooleanWrapperHolder(new Boolean(false)),
                    new FloatWrapperHolder(new Float(0)),
                    new DoubleWrapperHolder(new Double(0)),
                    new BigDecimalHolder(new BigDecimal(0)),
                    new IntegerWrapperHolder(new Integer(0)),
                    new ShortWrapperHolder(new Short((short)0)),
                    new ByteArrayHolder(new byte[0]),
                    new TimeHolder(new Time("12:01:30.150Z")),
                    new UnsignedLongHolder(new UnsignedLong(0)),
                    new UnsignedIntHolder(new UnsignedInt(0)),
                    new UnsignedShortHolder(new UnsignedShort(0)),
                    new UnsignedByteHolder(new UnsignedByte(0)),
                    new NonNegativeIntegerHolder(new NonNegativeInteger("0")),
                    new PositiveIntegerHolder(new PositiveInteger("1")),
                    new NonPositiveIntegerHolder(new NonPositiveInteger("0")),
                    new NegativeIntegerHolder(new NegativeInteger("-1")),
                    new URIHolder(new URI("urn:this-is-a-test")),
                    new YearHolder(new Year(1995)),
                    new MonthHolder(new Month(7)),
                    new DayHolder(new Day(13)),
                    new YearMonthHolder(new YearMonth(2002, 8)),
                    new MonthDayHolder(new MonthDay(8, 26))

            );
        }
        catch (RemoteException re) {
            re.printStackTrace();
            throw new AssertionFailedError("Remote Exception caught: " + re);
        }
        catch (Exception e) {
            // possibly thrown from Unsigned constructors
            // wont happen since we know the value are good!
        }
    } // allPrimitivesInout

    public void test2TypeTestAllPrimitivesInout() {
/*
        TypeTest binding = getProxyWithWSDL();
        allPrimitivesInout(binding);
        binding = getProxy();
        allPrimitivesInout(binding);
*/
    } // test2TypeTestAllPrimitivesInout

    private void allPrimitivesOut(TypeTest binding) {
        assertTrue("binding is null", binding != null);
        try {
            binding.allPrimitivesOut(
                    new StringHolder(),
                    new BigIntegerHolder(),
                    new IntHolder(),
                    new LongHolder(),
                    new ShortHolder(),
                    new BigDecimalHolder(),
                    new FloatHolder(),
                    new DoubleHolder(),
                    new BooleanHolder(),
                    new ByteHolder(),
                    new QNameHolder(),
                    new CalendarHolder(),
                    new ByteArrayHolder(),
                    new ByteArrayHolder(),
                    new StringHolder(),
                    new BooleanWrapperHolder(),
                    new FloatWrapperHolder(),
                    new DoubleWrapperHolder(),
                    new BigDecimalHolder(),
                    new IntegerWrapperHolder(),
                    new ShortWrapperHolder(),
                    new ByteArrayHolder(),
                    new TimeHolder(),
                    new UnsignedLongHolder(),
                    new UnsignedIntHolder(),
                    new UnsignedShortHolder(),
                    new UnsignedByteHolder(),
                    new NonNegativeIntegerHolder(),
                    new PositiveIntegerHolder(),
                    new NonPositiveIntegerHolder(),
                    new NegativeIntegerHolder(),
                    new URIHolder(),
                    new YearHolder(),
                    new MonthHolder(),
                    new DayHolder(),
                    new YearMonthHolder(),
                    new MonthDayHolder()

            );
        }
        catch (RemoteException re) {
            throw new AssertionFailedError("Remote Exception caught: " + re);
        }
    } // allPrimitivesOut

    public void test3TypeTestAllPrimitivesOut() {
/*
        TypeTest binding = getProxyWithWSDL();
        allPrimitivesOut(binding);
        binding = getProxy();
        allPrimitivesOut(binding);
*/
    } // test3TypeTestAllPrimitivesOut

/*
    public void test4TypeTestEnumIn() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.enumIn(test.wsdl.types.comprehensive_types.Enum.one);
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test5TypeTestEnumInout() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.enumInout(new test.wsdl.types.comprehensive_types.EnumHolder(test.wsdl.types.comprehensive_types.Enum.one));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test6TypeTestEnumOut() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.enumOut(new test.wsdl.types.comprehensive_types.EnumHolder());
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test7TypeTestEnumReturn() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            test.wsdl.types.comprehensive_types.Enum value = null;
            value = binding.enumReturn();
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test8TypeTestArrayIn() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.arrayIn(new String[0]);
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test9TypeTestArrayInout() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.arrayInout(new test.wsdl.types.comprehensive_types.ArrayHolder(new String[0]));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test10TypeTestArrayOut() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.arrayOut(new test.wsdl.types.comprehensive_types.ArrayHolder());
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test11TypeTestArrayReturn() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            String[] value = null;
            value = binding.arrayReturn();
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test12TypeTestArrayMIn() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.arrayMIn(new int[0][0][0]);
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test13TypeTestArrayMInout() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.arrayMInout(new test.wsdl.types.comprehensive_types.ArrayMHolder(new int[0][0][0]));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test14TypeTestArrayMOut() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.arrayMOut(new test.wsdl.types.comprehensive_types.ArrayMHolder());
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test15TypeTestArrayMReturn() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            int[][][] value = null;
            value = binding.arrayMReturn();
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test16TypeTestComplexAllIn() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.complexAllIn(new test.wsdl.types.comprehensive_types.ComplexAll());
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test17TypeTestComplexAllInout() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.complexAllInout(new test.wsdl.types.comprehensive_types.ComplexAllHolder(new test.wsdl.types.comprehensive_types.ComplexAll()));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test18TypeTestComplexAllOut() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.complexAllOut(new test.wsdl.types.comprehensive_types.ComplexAllHolder());
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test19TypeTestComplexAllReturn() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            test.wsdl.types.comprehensive_types.ComplexAll value = null;
            value = binding.complexAllReturn();
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test20TypeTestComplexSequenceIn() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.complexSequenceIn(new test.wsdl.types.comprehensive_types.ComplexSequence());
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test21TypeTestComplexSequenceInout() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.complexSequenceInout(new test.wsdl.types.comprehensive_types.ComplexSequenceHolder(new test.wsdl.types.comprehensive_types.ComplexSequence()));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test22TypeTestComplexSequenceOut() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.complexSequenceOut(new test.wsdl.types.comprehensive_types.ComplexSequenceHolder());
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test23TypeTestComplexSequenceReturn() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            test.wsdl.types.comprehensive_types.ComplexSequence value = null;
            value = binding.complexSequenceReturn();
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test24TypeTestElemWComplexIn() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.elemWComplexIn(new test.wsdl.types.comprehensive_types.ElemWComplex());
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test25TypeTestElemWComplexInout() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.elemWComplexInout(new test.wsdl.types.comprehensive_types.ElemWComplexHolder(new test.wsdl.types.comprehensive_types.ElemWComplex()));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test26TypeTestElemWComplexOut() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.elemWComplexOut(new test.wsdl.types.comprehensive_types.ElemWComplexHolder());
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test27TypeTestElemWComplexReturn() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            test.wsdl.types.comprehensive_types.ElemWComplex value = null;
            value = binding.elemWComplexReturn();
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test28TypeTestComplexWComplexIn() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.complexWComplexIn(new test.wsdl.types.comprehensive_types.ComplexWComplex());
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test29TypeTestComplexWComplexInout() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.complexWComplexInout(new test.wsdl.types.comprehensive_types.ComplexWComplexHolder(new test.wsdl.types.comprehensive_types.ComplexWComplex()));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test30TypeTestComplexWComplexOut() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.complexWComplexOut(new test.wsdl.types.comprehensive_types.ComplexWComplexHolder());
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test31TypeTestComplexWComplexReturn() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            test.wsdl.types.comprehensive_types.ComplexWComplex value = null;
            value = binding.complexWComplexReturn();
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test32TypeTestAnyIn() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.anyIn(new String());
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test33TypeTestAnyInout() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.anyInout(new ObjectHolder(new String()));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test34TypeTestAnyOut() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.anyOut(new ObjectHolder());
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test35TypeTestAnyReturn() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            Object value = null;
            value = binding.anyReturn();
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test36TypeTestAnimalIn() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.animalIn(new test.wsdl.types.comprehensive_types.Animal());
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test37TypeTestAnimalInout() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.animalInout(new test.wsdl.types.comprehensive_types.AnimalHolder(new test.wsdl.types.comprehensive_types.Animal()));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test38TypeTestAnimalOut() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.animalOut(new test.wsdl.types.comprehensive_types.AnimalHolder());
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test39TypeTestAnimalReturn() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            test.wsdl.types.comprehensive_types.Animal value = null;
            value = binding.animalReturn();
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test40TypeTestCatIn() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.catIn(new test.wsdl.types.comprehensive_types.Cat());
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test41TypeTestCatInout() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.catInout(new test.wsdl.types.comprehensive_types.CatHolder(new test.wsdl.types.comprehensive_types.Cat()));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test42TypeTestCatOut() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            binding.catOut(new test.wsdl.types.comprehensive_types.CatHolder());
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test43TypeTestCatReturn() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            test.wsdl.types.comprehensive_types.Cat value = null;
            value = binding.catReturn();
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test44TypeTestMethodBoolean() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            boolean value = false;
            value = binding.methodBoolean(true, new BooleanHolder(true));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test45TypeTestMethodByte() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            byte value = -3;
            value = binding.methodByte((byte)0, new ByteHolder((byte)0));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test46TypeTestMethodShort() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            short value = -3;
            value = binding.methodShort((short)0, new ShortHolder((short)0));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test47TypeTestMethodInt() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            int value = -3;
            value = binding.methodInt(0, new IntHolder(0));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test48TypeTestMethodLong() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            long value = -3;
            value = binding.methodLong(0, new LongHolder(0));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test49TypeTestMethodFloat() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            float value = -3;
            value = binding.methodFloat(0, new FloatHolder(0));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test50TypeTestMethodDouble() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            double value = -3;
            value = binding.methodDouble(0, new DoubleHolder(0));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test51TypeTestMethodString() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            String value = null;
            value = binding.methodString(new String(), new StringHolder(new String()));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test52TypeTestMethodInteger() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            java.math.BigInteger value = null;
            value = binding.methodInteger(new java.math.BigInteger("0"), new BigIntegerHolder(new java.math.BigInteger("0")));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test53TypeTestMethodDecimal() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            java.math.BigDecimal value = null;
            value = binding.methodDecimal(new java.math.BigDecimal(0), new BigDecimalHolder(new java.math.BigDecimal(0)));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test54TypeTestMethodDateTime() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            java.util.Calendar value = null;
            value = binding.methodDateTime(java.util.Calendar.getInstance(), new CalendarHolder(java.util.Calendar.getInstance()));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test55TypeTestMethodQName() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            javax.xml.namespace.QName value = null;
            value = binding.methodQName(new javax.xml.namespace.QName("http://double-double", "toil-and-trouble"), new QNameHolder(new javax.xml.namespace.QName("http://double-double", "toil-and-trouble")));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test56TypeTestMethodSoapString() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            String value = null;
            value = binding.methodSoapString(new String(), new StringHolder(new String()));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test57TypeTestMethodSoapBoolean() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            Boolean value = null;
            value = binding.methodSoapBoolean(new Boolean(false), new BooleanWrapperHolder(new Boolean(false)));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test58TypeTestMethodSoapFloat() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            Float value = null;
            value = binding.methodSoapFloat(new Float(0), new FloatWrapperHolder(new Float(0)));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test59TypeTestMethodSoapDouble() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            Double value = null;
            value = binding.methodSoapDouble(new Double(0), new DoubleWrapperHolder(new Double(0)));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test60TypeTestMethodSoapDecimal() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            java.math.BigDecimal value = null;
            value = binding.methodSoapDecimal(new java.math.BigDecimal(0), new BigDecimalHolder(new java.math.BigDecimal(0)));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test61TypeTestMethodSoapInt() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            Integer value = null;
            value = binding.methodSoapInt(new Integer(0), new IntegerWrapperHolder(new Integer(0)));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }

    public void test62TypeTestMethodSoapShort() {
        test.wsdl.types.comprehensive_service.TypeTest binding;
        try {
            binding = new test.wsdl.types.comprehensive_service.TypeTestServiceLocator().getTypeTest();
        }
        catch (javax.xml.rpc.ServiceException jre) {
            throw new junit.framework.AssertionFailedError("JAX-RPC ServiceException caught: " + jre);
        }
        assertTrue("binding is null", binding != null);

        try {
            Short value = null;
            value = binding.methodSoapShort(new Short((short)0), new ShortWrapperHolder(new Short((short)0)));
        }
        catch (java.rmi.RemoteException re) {
            throw new junit.framework.AssertionFailedError("Remote Exception caught: " + re);
        }
    }
*/
}


text:
package de.intarsys.tools.transaction;

import java.io.Serializable;

/**
 * A common implementation for the {@link IResource} abstraction.
 *
 * @param <R>
 * @param <T>
 */
abstract public class CommonResource<R extends IResource, T extends IResourceType<R>>
		implements IResource, Serializable {

	final private T type;

	final private R parent;

	private boolean active = false;

	private static int Counter = 0;

	public static int getCounter() {
		return Counter;
	}

	public static void setCounter(int counter) {
		Counter = counter;
	}

	final private int id = Counter++;

	protected CommonResource(T type, R parent) {
		super();
		this.type = type;
		this.parent = parent;
	}

	public void begin() throws ResourceException {
		setActive(true);
	}

	public void commit() throws ResourceException {
	}

	public int getId() {
		return id;
	}

	public R getParent() {
		return parent;
	}

	public T getType() {
		return type;
	}

	protected boolean isActive() {
		return active;
	}

	public void resume() {
		setActive(true);
	}

	public void rollback() throws ResourceException {
	}

	protected void setActive(boolean active) {
		this.active = active;
	}

	public void suspend() {
		setActive(false);
	}

}

redpajama_set_name: RedPajamaGithub


text:
using ITGlobal.MarkDocs.Extensions;

namespace ITGlobal.MarkDocs.Search.Impl
{
    /// <summary>
    ///     A factory for search extension
    /// </summary>
    internal sealed class SearchExtensionFactory : IExtensionFactory
    {
        private readonly LuceneSearchEngine _engine;

        public SearchExtensionFactory(LuceneSearchEngine engine)
        {
            _engine = engine;
        }

        public IExtension Create(IMarkDocService service) => new SearchExtension(_engine);
    }
}


text:
from annoying.functions import get_object_or_None
from celery import task
from celery.utils.log import get_task_logger
import settings as text_settings

logger = get_task_logger(__name__)

@task(rate_limit='1/s')
def process_text(text_id):
    from models import Text
    logger.debug('processing text %d' % (text_id))
    text = get_object_or_None(Text, id=text_id)
    if text is not None:
        text.status = text_settings.TEXT_STATUS_PROCESSING
        text.save()

        text.parse()
        text.status = text_settings.TEXT_STATUS_FINISHED
        text.save()


text:
function JuegoLaberinto(){
	this.nombre="JuegoLaberinto";
	this.laberinto=null;
	this.crearLaberinto=function(){
		this.laberinto=new Laberinto();
		var h1=new Habitacion();
		var h2=new Habitacion();
		var puerta=new Puerta(h1,h2);
		//h1.lados[0]=puerta;
		//h2.lados[2]=puerta;
		h1.norte=puerta;
		h2.sur=puerta;
		this.laberinto.agregarHabitacion(h1);
		this.laberinto.agregarHabitacion(h2);
		return this.laberinto
	}
}

function Laberinto(){
	this.nombre="Laberinto";
	this.habitaciones=[];
	this.agregarHabitacion=function(hab){
		hab.id=this.habitaciones.length;
		this.habitaciones.push(hab);
	}
	this.obtenerHabitacion=function(num){
		return this.habitaciones[num];
	}
}

function Pared(){
	this.nombre="Pared";
}

function Habitacion(){
	this.nombre="Habitacion";
	this.id=null;
	//this.lados=[];
	this.norte=null;
	this.este=null;
	this.oeste=null;
	this.sur=null;
	//this.agregarLado=function(em){
	//	this.lados.push(em);
	//}
	//this.lados.push(new Pared());
	//this.lados.push(new Pared());
	//this.lados.push(new Pared());
	//this.lados.push(new Pared());
	this.norte=new Pared();
	this.este=new Pared();
	this.oeste=new Pared();
	this.sur=new Pared();
}

function Puerta(h1,h2){
	this.nombre="Puerta";
	this.h1=h1;
	this.h2=h2;
}

function Norte(){
	this.nombre="Norte";
}

function Este(){
	this.nombre="Este";
}
function Oeste(){
	this.nombre="Oeste";
}
function Sur(){
	this.nombre="Sur";
}


text:
package main

import (
	"fmt"
	"github.com/spf13/cobra"
)

func main() {
	CmdGet.AddCommand(CmdGetContact)
	RootCmd.AddCommand(CmdGet)
	RootCmd.AddCommand(CmdPut)
	RootCmd.Execute()
}

var CmdGet = &cobra.Command{
	Use:   "get",
	Short: "short message for get",
	Long:  "long message for get",
	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("executing get")
	},
}

var CmdGetContact = &cobra.Command{
	Use:   "contact",
	Short: "short message for get contact",
	Long:  "long message for get contact",
	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("executing get contact")
	},
}

var CmdPut = &cobra.Command{
	Use:   "put",
	Short: "short message for put",
	Long:  "long message for put",
	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("executing put")
	},
}

var RootCmd = &cobra.Command{Use: "mycli"}


text:
import argparse
from datetime import datetime

import dlrnapi_client
import promoter_utils
from influxdb_utils import format_ts_from_float, format_ts_from_last_modified

PROMOTION_INFLUXDB_LINE = ("dlrn-promotion,"
                           "release={release},distro={distro},"
                           "name={promote_name} "
                           "commit_hash=\"{commit_hash}\","
                           "distro_hash=\"{distro_hash}\","
                           "repo_hash=\"{repo_hash}\","
                           "repo_url=\"{repo_url}\","
                           "consistent_date={consistent_date},"
                           "promotion_details=\"{promotion_details}\","
                           "component=\"{component}\","
                           "extended_hash=\"{extended_hash}\" "
                           "{timestamp}")

DEFAULT_PROMOTER_BASE_URL = (
    "https://raw.githubusercontent.com/rdo-infra/ci-config/master"
)

def influxdb(promotion):
    if 'extended_hash' not in promotion.keys():
        promotion['extended_hash'] = None
    promotion['timestamp'] = format_ts_from_float(promotion['timestamp'])
    return PROMOTION_INFLUXDB_LINE.format(**promotion)

def get_dlrn_client(url, release, distro, component):
    promoter_config = promoter_utils.get_promoter_config(
        url, release, distro, component
    )
    dlrn_client = promoter_utils.get_dlrn_client(promoter_config, component)
    return dlrn_client

def get_dlrn_promotions(dlrn_client, name, component=None):
    query = dlrnapi_client.PromotionQuery()
    query.promote_name = name
    if component:
        query.component = component
    promotions = dlrn_client.api_promotions_get(query)
    return promotions

def get_last_promotion(promotions, release, distro, component=None):
    if promotions:
        # TO-DO
        # perhaps loop through the promotions and
        # ensure [0] is in fact the latest
        last_promotion = promotions[0].to_dict()
        last_promotion['release'] = release
        last_promotion['distro'] = distro
        # sanitize dict
        if last_promotion['component'] is None:
            last_promotion['component'] = "none"
        return last_promotion
    return

def update_promotion(promo, promotion_details, consistent):

    if promo and consistent:
        promo.update({'consistent_date': consistent})
    if promo and promotion_details:
        promo.update({'promotion_details': promotion_details})

    return promo

if __name__ == '__main__':

    parser = argparse.ArgumentParser(
        description="Print release last promotions as influxdb lines",
        formatter_class=argparse.ArgumentDefaultsHelpFormatter
    )

    parser.add_argument(
        '--release',
        required=True,
        choices=[
            'osp17', 'osp16-2', 'master', 'wallaby', 'train'
        ],
        help='Upstream or downstream release.'
    )
    parser.add_argument(
        '--distro',
        default='centos-8',
        choices=['centos-8', 'centos-9', 'rhel-8', 'rhel-9'],
        help='Distribution to query.'
    )
    parser.add_argument(
        '--component',
        default=None,
        help='Specific OpenStack component (e.g., compute, security).'
    )
    parser.add_argument(
        '--url',
        default=DEFAULT_PROMOTER_BASE_URL,
        help='Promoter repository base URL.'
    )
    parser.add_argument(
        '--human',
        default=False,
        action='store_true',
        help='Display results for a human, not influx'
    )
    promotions = []
    args = parser.parse_args()

    # align args w/ ruck_rover.py
    if args.distro == "centos-8":
        args.distro = "CentOS-8"
    elif args.distro == "centos-9":
        args.distro = "CentOS-9"
    elif args.distro == "rhel-8":
        args.distro = "RedHat-8"
    elif args.distro == "rhel-9":
        args.distro = "RedHat-9"

    if args.release == "osp16-2":
        args.release = "rhos-16.2"
    elif args.release == "osp17":
        args.release = "rhos-17"

    promoter_config = promoter_utils.get_promoter_config(args.url,
                                                         args.release,
                                                         args.distro,
                                                         args.component)

    dlrn_client = get_dlrn_client(args.url,
                                  args.release,
                                  args.distro,
                                  args.component)
    # with components we are only concerned with promotions to
    # promoted-components
    if args.component is not None:
        promoter_config['promotions'] = ["promoted-components"]

    for promotion_name in promoter_config['promotions']:
        promos = get_dlrn_promotions(dlrn_client,
                                     promotion_name,
                                     args.component)

        promo = get_last_promotion(promos,
                                   args.release,
                                   args.distro,
                                   args.component)

        if promo:
            promotion_details = promoter_utils.get_url_promotion_details(
                promoter_config, promo, args.component)

            consistent = format_ts_from_last_modified(
                promoter_utils.get_consistent(promoter_config, args.component))

            promo = update_promotion(promo,
                                     promotion_details,
                                     consistent)
            promotions.append(promo)

    if not args.human:
        for promotion in promotions:
            print(influxdb(promotion))
    else:
        for pr in promotions:
            delin = " ============ "
            ct = int(str(pr['consistent_date'])[:-3])
            pt = datetime.utcfromtimestamp(pr['timestamp'])
            ct = datetime.utcfromtimestamp(ct)
            age = ct - pt
            line = "\n{} promoted tag: {}, {} days old {}"
            print(line.format(delin,
                              pr['promote_name'],
                              age.days,
                              delin))
            for key, value in pr.items():
                print("{}: {}".format(key, value))


text:
#include "../toe.hpp"

using namespace hls;

void ack_delay(	stream<extendedEvent>&	input,
				stream<extendedEvent>&	output,
				stream<ap_uint<1> >&	readCountFifo,
				stream<ap_uint<1> >&	writeCountFifo);


text:
"""
:mod:`zsl.utils.deploy.js_model_generator`
------------------------------------------

.. moduleauthor:: Peter Morihladko
"""
from __future__ import unicode_literals

from builtins import object, range
import hashlib
import importlib
import json
import sys
from typing import Union

import sqlalchemy.exc
from sqlalchemy.orm import class_mapper

from zsl.utils.deploy.integrator import integrate_to_file
from zsl.utils.string_helper import camelcase_to_underscore, underscore_to_camelcase

model_tpl = """    {model_prefix}{model_name} = {model_fn}.extend({{
        urlRoot: App.service_url + 'resource/{resource_name}',
        schema: {schema}
    }});

    {collection_prefix}{model_name} = {collection_fn}.extend({{
        model: {model_prefix}{model_name},
        url: {model_prefix}{model_name}.prototype.urlRoot
    }});
"""

list_opts_tpl = """function(callback, field) {{
                    field.setOptions(new {collection_prefix}{model_name}([],{{limit: 'unlimited'}}));
                }}"""

class ModelGenerator(object):
    def __init__(self, module, model_prefix="", collection_prefix="", model_fn="Atteq.bb.Model",
                 collection_fn="Atteq.bb.Collection"):
        self.model_prefix = model_prefix
        self.collection_prefix = collection_prefix
        self.model_fn = model_fn
        self.collection_fn = collection_fn
        self.table_to_class = {}

        self.models = importlib.import_module(module)

    def _get_list_options(self, column):
        fk = list(column.foreign_keys)[0]

        table_name = underscore_to_camelcase(fk.column.table.name)

        return list_opts_tpl.format(collection_prefix=self.collection_prefix, model_name=table_name)

    def _map_table_name(self, model_names):
        """
        Pre foregin_keys potrbejeme pre z nazvu tabulky zistit class,
        tak si to namapujme
        """

        for model in model_names:
            if isinstance(model, tuple):
                model = model[0]

            try:
                model_cls = getattr(self.models, model)
                self.table_to_class[class_mapper(model_cls).tables[0].name] = model
            except AttributeError:
                pass

    def generate_model(self, model_name, model_plural=None):
        if model_name not in dir(self.models):
            raise ImportError(
                "Model [{name}] couldn't be found in {module}\n".format(name=model_name, module=self.models.__name__))

        if model_plural is None:
            model_plural = model_name + 's'

        model = getattr(self.models, model_name)

        schema = {}
        mapper = class_mapper(model)
        callbacks = []

        for column in mapper.columns:
            col_type = column.type.__class__.__name__
            attrs = {}

            if column.primary_key:
                continue

            if column.foreign_keys:
                try:
                    attrs['type'] = 'AtteqSelect'
                    attrs['options'] = '__CALLBACK__%d' % len(callbacks)
                    callbacks.append(self._get_list_options(column))

                    # TODO uf uf uuuuf
                    fk_table = list(column.foreign_keys)[0].target_fullname.split('.')[0]

                    if fk_table in self.table_to_class:
                        attrs['foreign_model'] = '%s%s' % (self.model_prefix, self.table_to_class[fk_table])

                except sqlalchemy.exc.NoReferencedTableError:
                    attrs['type'] = 'Text'

            elif col_type == 'TEXT':
                attrs['type'] = "TextArea"

            elif col_type == 'Enum':
                attrs['type'] = 'AtteqSelect' if column.nullable else 'Select'
                attrs['options'] = column.type.enums

            elif col_type == 'INTEGER':
                attrs['type'] = 'Number'

            else:
                attrs['type'] = "Text"

            if column.nullable:
                attrs['nullable'] = True

            schema[column.name] = attrs

        schema = "\n        ".join(json.dumps(schema, indent=4).split("\n"))

        for i in range(len(callbacks)):
            schema = schema.replace('"__CALLBACK__%d"' % i, callbacks[i])

        return model_tpl.format(
            model_name=model_name,
            model_prefix=self.model_prefix,
            collection_prefix=self.collection_prefix,
            resource_name=camelcase_to_underscore(model_plural),
            model_fn=self.model_fn,
            collection_fn=self.collection_fn,
            schema=schema
        )

    def generate_models(self, models):
        js_models = []

        self._map_table_name(models)

        for model in models:
            if isinstance(model, tuple):
                model_name = model[0]
                model_plural = model[1]
            else:
                model_name = model
                model_plural = None

            js_model = self.generate_model(model_name, model_plural)
            js_models.append(js_model)

        return js_models

def parse_model_arg(models):
    # type: (list[str]) -> list[str]
    """Parse the model argument definition."""
    return [tuple(m.split('/')) if '/' in m else m for m in models]

def generate_js_models(module, models, collection_prefix, model_prefix,
                       model_fn, collection_fn, marker, integrate, js_file):
    # type: (str, str, str, str, str, str, str, bool, str) -> Union[str, None]
    """Generate models for Backbone Javascript applications.

    :param module: module from which models are imported
    :param models: model name, can be a tuple WineCountry/WineCountries as singular/plural
    :param model_prefix: namespace prefix for models (app.models.)
    :param collection_prefix: namespace prefix for collection (App.collections.)
    :param model_fn: name of model constructor (MyApp.bb.Model)
    :param collection_fn: name of collection constructor (MyApp.bb.Collection)
    :param marker: marker to indicate the auto generated code
    :param integrate: integrate to file
    :param js_file: file to integrate
    :return: generated models or nothing if writing into a file
    """

    options = {
        'model_prefix': model_prefix,
        'collection_prefix': collection_prefix,
        'model_fn': model_fn,
        'collection_fn': collection_fn
    }

    generator = ModelGenerator(module,
                               **{o: options[o] for o in options if options[o] is not None})

    models = generator.generate_models(parse_model_arg(models))

    if integrate:
        sys.stderr.write("Integrate is really experimental")

        if not marker:
            marker = hashlib.md5("{0}{1}".format(module, models)).hexdigest()

        start = "// * -- START AUTOGENERATED %s -- * //\n" % marker
        end = "// * -- END AUTOGENERATED %s -- * //\n" % marker

        return integrate_to_file("\n".join(models), js_file, start, end)

    else:
        return "\n".join(models)


text:
namespace ps2emu
{

typedef unsigned char uint8;
typedef unsigned short uint16;
typedef unsigned int uint32;
typedef char int8;
typedef short int16;
typedef int int32;

typedef unsigned int uint;

typedef unsigned char u8;
typedef signed char s8;
typedef char c8;

typedef unsigned short u16;
typedef short s16;

typedef unsigned int u32;
typedef int s32;

#if defined(__GNUC__)
typedef uint64_t u64;
typedef int64_t s64;
#else
typedef unsigned __int64 u64;
typedef __int64 s64;
#endif

#ifndef WIN32
typedef unsigned long long uint64;
typedef long long int64;
#else
typedef unsigned long uint64;
typedef long int64;
#endif

typedef struct int128 {
   uint64 lo, hi;
} int128;

typedef struct fvec {
   float x,y,z,w;
} fvec;

typedef struct ivec {
    uint32 x, y, z, w;
} ivec;

typedef struct ivec16 {
	int16 x,y,z,w;
}ivec16;

typedef union vec {
	int128 value;
	fvec vf;
	ivec mi;
	int16 vi;
}vec;

typedef struct quadvector {
	int32 x, y, z, w;
} quadvector;

}

#endif


text:
angular.module('test.controllers')
  .controller('HomeCtrl', ['$scope', 'Users', function($scope, Users) {
    Users.query(function(err, users
) {
      if (err) {
        Materialize.toast('Failed to fetct users', 5000);
      } else {
        $scope.users = users;
      }
    });
  }]);


text:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <parent>
        <artifactId>keycloak-examples-parent</artifactId>
        <groupId>org.keycloak</groupId>
        <version>1.4.0.Final-SNAPSHOT</version>
    </parent>

    <name>Examples</name>
    <description/>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>keycloak-examples-demo-parent</artifactId>
    <packaging>pom</packaging>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-deploy-plugin</artifactId>
                <configuration>
                    <skip>true</skip>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <modules>
        <!-- <module>server</module> -->
        <module>customer-app</module>
        <module>customer-app-cli</module>
        <module>customer-app-js</module>
        <module>product-app</module>
        <module>example-ear</module>
        <module>admin-access-app</module>
        <module>angular-product-app</module>
        <module>database-service</module>
        <module>third-party</module>
        <module>third-party-cdi</module>
    </modules>

    <profiles>
        <profile>
            <id>no-keycloak-json</id>
            <activation>
                <property>
                    <name>no-keycloak-json</name>
                </property>
            </activation>
            <build>
                <plugins>
                    <plugin>
                        <artifactId>maven-war-plugin</artifactId>
                        <configuration>
                            <packagingExcludes>**/keycloak.json</packagingExcludes>
                        </configuration>
                    </plugin>
                </plugins>
            </build>
        </profile>
    </profiles>
</project>


text:
package org.qi4j.library.shiro.domain.permissions;

import org.qi4j.api.entity.EntityBuilder;
import org.qi4j.api.injection.scope.Structure;
import org.qi4j.api.mixin.Mixins;
import org.qi4j.api.service.ServiceComposite;
import org.qi4j.api.unitofwork.UnitOfWork;
import org.qi4j.api.unitofwork.UnitOfWorkFactory;

@Mixins( PermissionFactory.Mixin.class )
public interface PermissionFactory
        extends ServiceComposite
{

    Permission create( String permissionString );

    abstract class Mixin
            implements PermissionFactory
    {

        @Structure
        private UnitOfWorkFactory uowf;

        public Permission create( String permissionString )
        {
            UnitOfWork uow = uowf.currentUnitOfWork();
            EntityBuilder<Permission> permissionBuilder = uow.newEntityBuilder( Permission.class );
            Permission permission = permissionBuilder.instance();
            permission.string().set( permissionString );
            return permissionBuilder.newInstance();
        }

    }

}