detailedinouttestcase.java

Java有关XML编程需要用到axis 的源代码 把里面bin下的包导入相应的Java工程 进行使用

        {
            ret = io.out1Inout1In1 (sh, expectedAddress);
            assertEquals("out1Inout1In1 yo ho ho!", sh.value);
            assertEquals("out1Inout1In1 arghhh!", ret);
        }
        catch (Throwable t)
        {
            throw new AssertionFailedError("Test failure:  out1Inout1In1\nexpected string1 = out1Inout1In1 yo ho ho!\nactual string1 = "
                                           + sh.value + "\nexpected string2 = out1Inout1In1 arghhh!\nactual string2 = " + ret);
        }
    }

    public void testOut1Inout1InMany ()
    {
        StringHolder sh = new StringHolder ("out1Inout1InMany");
        String ret = null;
        try
        {
            ret = io.out1Inout1InMany (sh, expectedAddress, expectedPhone);
            assertEquals("out1Inout1InMany yo ho ho!", sh.value);
            assertEquals("out1Inout1InMany arghhh!", ret);
        }
        catch (Throwable t)
        {
            throw new AssertionFailedError("Test failure:  out1Inout1InMany\nexpected string1 = out1Inout1InMany yo ho ho!\nactual string1 = "
                                           + sh.value + "\nexpected string2 = out1Inout1InMany arghhh!\nactual string2 = " + ret + t.getMessage());
        }
    }

    public void testOut1InoutManyIn0 ()
    {
        StringHolder sh = new StringHolder ("out1InoutManyIn0");
        AddressHolder ah = new AddressHolder (expectedAddress);
        String ret = null;
        try
        {
            ret = io.out1InoutManyIn0 (sh, ah);
            assertEquals("out1InoutManyIn0 yo ho ho!", sh.value);
            assertTrue(equals (ah.value, returnAddress));
            assertEquals("out1InoutManyIn0 arghhh!", ret);
        }
        catch (Throwable t)
        {
            throw new AssertionFailedError("Test failure:  out1InoutManyIn0\nexpected string1 = out1InoutManyIn0 yo ho ho!\nactual string1 = "
                                           + sh.value + "\nexpected address = " + printAddress (returnAddress)
                                           + "\nactual address = " + printAddress (ah.value)
                                           + "\nexpected string2 = out1InoutManyIn0 arghhh!\nactual string2 = " + ret + t.getMessage());
        }
    }

    public void testOut1InoutManyIn1 ()
    {
        StringHolder sh = new StringHolder ("out1InoutManyIn1");
        AddressHolder ah = new AddressHolder (expectedAddress);
        String ret = null;
        try
        {
            ret = io.out1InoutManyIn1 (sh, ah, expectedPhone);
            assertEquals("out1InoutManyIn1 yo ho ho!", sh.value);
            assertTrue(equals (ah.value, returnAddress));
            assertEquals("out1InoutManyIn1 arghhh!", ret);
        }
        catch (Throwable t)
        {
            throw new AssertionFailedError("Test failure:  out1InoutManyIn1\nexpected string1 = out1InoutManyIn1 yo ho ho!\nactual string1 = "
                                           + sh.value + "\nexpected address = " + printAddress (returnAddress)
                                           + "\nactual address = " + printAddress (ah.value)
                                           + "\nexpected string2 = out1InoutManyIn1 arghhh!\nactual string2 = " + ret + t.getMessage());
        }
    }

    public void testOut1InoutManyInMany ()
    {
        StringHolder sh = new StringHolder ("out1InoutManyInMany");
        AddressHolder ah = new AddressHolder (expectedAddress);
        String ret = null;
        try
        {
            ret = io.out1InoutManyInMany (sh, ah, expectedPhone, expectedNumber);
            assertEquals("out1InoutManyInMany yo ho ho!", sh.value);
            assertTrue(equals (ah.value, returnAddress));
            assertEquals("out1InoutManyInMany arghhh!", ret);
        }
        catch (Throwable t)
        {
            throw new AssertionFailedError("Test failure:  out1InoutManyInMany\nexpected string1 = out1InoutManyInMany yo ho ho!\nactual string1 = "
                                           + sh.value + "\nexpected address = " + printAddress (returnAddress)
                                           + "\nactual address = " + printAddress (ah.value)
                                           + "\nexpected string2 = out1InoutManyInMany arghhh!\nactual string2 = " + ret + t.getMessage());
        }
    }

    public void testOutManyInout0In0 ()
    {
        StringHolder sh = new StringHolder("outManyInout0In0");
        AddressHolder ah = new AddressHolder (expectedAddress);
        try
        {
            io.outManyInout0In0 (sh, ah);
            assertEquals (sh.value, " arghhh!");
            assertTrue(equals (ah.value, returnAddress));
        }
        catch (Throwable t)
        {
            throw new AssertionFailedError("Test failure:  outManyInout0In0\nexpected address = "
                    + printAddress (returnAddress) + "\nactual address = "
                    + printAddress (ah.value)
                    + "\nexpected string =  arghhh!\nactual string = "
                    + sh.value + " " + t.getMessage());
        }
    }

    public void testOutManyInout0In1 ()
    {
        IntHolder ih = new IntHolder();
        StringHolder sh = new StringHolder ();
        try
        {
            io.outManyInout0In1 ("outManyInout0In1", ih, sh);
            assertEquals(returnNumber, ih.value);
            assertEquals(" yo ho ho!", sh.value);
        }
        catch (Throwable t)
        {
            throw new AssertionFailedError("Test failure:  outManyInout0In1\nexpected string =  yo ho ho!\nactual string = "
                    + sh.value + "\nexpected number = " + returnNumber
                    + "\nactual number = " + ih.value + " " + t.getMessage());
        }
    }

    public void testOutManyInout0InMany ()
    {
        IntHolder ih = new IntHolder();
        StringHolder sh = new StringHolder ();
        try
        {
            io.outManyInout0InMany ("outManyInout0InMany", expectedAddress, ih, sh);
            assertEquals(returnNumber, ih.value);
            assertEquals(" yo ho ho!", sh.value);
        }
        catch (Throwable t)
        {
            throw new AssertionFailedError("Test failure:  outManyInout0InMany\nexpected string =  yo ho ho!\nactual string = "
                    + sh.value + "\nexpected number = " + returnNumber
                    + "\nactual number = " + ih.value + " " + t.getMessage());
        }
    }

    public void testOutManyInout1In0 ()
    {
        StringHolder shinout = new StringHolder ("outManyInout1In0");
        IntHolder ihout = new IntHolder();
        StringHolder shout = new StringHolder ();
        try
        {
            io.outManyInout1In0 (shinout, ihout, shout);
            assertEquals("outManyInout1In0 yo ho ho!", shinout.value);
            assertEquals(returnNumber, ihout.value);
            assertEquals(" yo ho ho!", shout.value);
        }
        catch (Throwable t)
        {
            throw new AssertionFailedError("Test failure:  outManyInout1In0\nexpected string1 = outManyInout1In0 yo ho ho!\nactual string1 = "
                    + shinout.value
                    + "\nexpected string2 =  yo ho ho!\nactual string2 = "
                    + shout.value + "\nexpected number = " + returnNumber
                    + "\nactual number = " + ihout.value + " "
                    + t.getMessage());
        }
    }

    public void testOutManyInout1In1 ()
    {
        StringHolder shinout = new StringHolder ("outManyInout1In1");
        IntHolder ihout = new IntHolder();
        StringHolder shout = new StringHolder ();
        try
        {
            io.outManyInout1In1 (shinout, expectedAddress, ihout, shout);
            assertEquals("outManyInout1In1 yo ho ho!", shinout.value);
            assertEquals(returnNumber, ihout.value);
            assertEquals(" yo ho ho!", shout.value);
        }
        catch (Throwable t)
        {
            throw new AssertionFailedError("Test failure:  outManyInout1In1\nexpected string1 = outManyInout1In1 yo ho ho!\nactual string = "
                    + shinout.value
                    + "\nexpected string2 =  yo ho ho!\nactual string2 = "
                    + shout.value + "\nexpected number = " + returnNumber
                    + "\nactual number = " + ihout.value + " "
                    + t.getMessage());
        }
    }

    public void testOutManyInout1InMany ()
    {
        PhoneHolder ph = new PhoneHolder (expectedPhone);
        IntHolder ih = new IntHolder();
        StringHolder sh = new StringHolder ();
        try
        {
            io.outManyInout1InMany ("outManyInout1InMany", expectedAddress, ph, ih, sh);
            assertTrue(equals (ph.value, returnPhone));
            assertEquals(returnNumber, ih.value);
            assertEquals(" yo ho ho!", sh.value);
        }
        catch (Throwable t)
        {
            throw new AssertionFailedError("Test failure:  outManyInout1InMany\nexpected phone = "
                    + printPhone (returnPhone) + "\nactual phone = "
                    + printPhone (ph.value)
                    + "\nexpected string =  yo ho ho!\nactual string = "
                    + sh.value + "\nexpected number = " + returnNumber
                    + "\nactual number = " + ih.value + " " + t.getMessage());
        }
    }

    public void testOutManyInoutManyIn0 ()
    {
        StringHolder shinout = new StringHolder ("outManyInoutManyIn0");
        AddressHolder ah = new AddressHolder (expectedAddress);
        IntHolder ihout = new IntHolder();
        StringHolder shout = new StringHolder ();
        try
        {
            io.outManyInoutManyIn0 (shinout, ah, ihout, shout);
            assertEquals("outManyInoutManyIn0 yo ho ho!", shinout.value);
            assertTrue(equals (ah.value, returnAddress));
            assertEquals(returnNumber, ihout.value);
            assertEquals(" yo ho ho!", shout.value);
        }
        catch (Throwable t)
        {
            throw new AssertionFailedError("Test failure:  outManyInoutManyIn0\nexpected string1 = outManyInoutManyIn0 yo ho ho!\nactual string1 = "
                    + shinout.value + "\nexpected address = "
                    + printAddress (returnAddress) + "\nactual address = "
                    + printAddress (ah.value)
                    + "\nexpected string2 =  yo ho ho!\nactual string2 = "
                    + shout.value + "\nexpected number = " + returnNumber
                    + "\nactual number = " + ihout.value + " "
                    + t.getMessage());
        }
    }

    public void testOutManyInoutManyIn1 ()
    {
        StringHolder shinout = new StringHolder ("outManyInoutManyIn1");
        AddressHolder ah = new AddressHolder (expectedAddress);
        IntHolder ihout = new IntHolder();
        StringHolder shout = new StringHolder ();
        try
        {
            io.outManyInoutManyIn1 (shinout, ah, expectedPhone, ihout, shout);
            assertEquals("outManyInoutManyIn1 yo ho ho!", shinout.value);
            assertTrue(equals (ah.value, returnAddress));
            assertEquals(returnNumber, ihout.value);
            assertEquals(" yo ho ho!", shout.value);
        }
        catch (Throwable t)
        {
            throw new AssertionFailedError("Test failure:  outManyInoutManyIn1\nexpected string1 = outManyInoutManyIn1 yo ho ho!\nactual string1 = "
                    + shinout.value + "\nexpected address = "
                    + printAddress (returnAddress) + "\nactual address = "
                    + printAddress (ah.value)
                    + "\nexpected string2 =  yo ho ho!\nactual string2 = "
                    + shout.value + "\nexpected number = " + returnNumber
                    + "\nactual number = " + ihout.value + " "
                    + t.getMessage());
        }
    }

    public void testOutManyInoutManyInMany ()
    {
        StringHolder shinout = new StringHolder ("outManyInoutManyInMany");
        AddressHolder ah = new AddressHolder (expectedAddress);
        IntHolder ihout = new IntHolder();
        StringHolder shout = new StringHolder ();
        try
        {
            io.outManyInoutManyInMany (shinout, ah, expectedPhone, expectedNumber, ihout, shout);
            assertEquals("outManyInoutManyInMany yo ho ho!", shinout.value);
            assertTrue(equals (ah.value, returnAddress));
            assertEquals(returnNumber, ihout.value);
            assertEquals(" yo ho ho!", shout.value);
        }
        catch (Throwable t)
        {
            throw new AssertionFailedError("Test failure:  outManyInoutManyInMany\nexpected string1 = outManyInoutManyInMany yo ho ho!\nactual string1 = "
                    + shinout.value + "\nexpected address = "
                    + printAddress (returnAddress) + "\nactual address = "
                    + printAddress (ah.value)
                    + "\nexpected string2 =  yo ho ho!\nactual string2 = "
                    + shout.value + "\nexpected number = " + returnNumber
                    + "\nactual number = " + ihout.value + " "
                    + t.getMessage());
        }
    }
    public void testDateInout ()
    {
        org.apache.axis.holders.DateHolder dh = new DateHolder(expectedDate);
        try
        {
            io.dateInout (dh);
            assertTrue("Output date does not match", returnDate.equals(dh.value));
            
        }
        catch (Throwable t)
        {
            throw new AssertionFailedError("Test failure: dateInout: " + t.getMessage());
        }
    }

}