CorbaTypesTestCase.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.    
 */

package org.apache.tuscany.sca.binding.corba.testing;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import java.lang.annotation.Annotation;
import java.lang.reflect.Array;

import junit.framework.Assert;

import org.apache.tuscany.sca.binding.corba.provider.exceptions.CorbaException;
import org.apache.tuscany.sca.binding.corba.provider.exceptions.RequestConfigurationException;
import org.apache.tuscany.sca.binding.corba.provider.reference.DynaCorbaRequest;
import org.apache.tuscany.sca.binding.corba.provider.reference.DynaCorbaResponse;
import org.apache.tuscany.sca.binding.corba.testing.enums.Color;
import org.apache.tuscany.sca.binding.corba.testing.exceptions.CalcPackage.DivByZero;
import org.apache.tuscany.sca.binding.corba.testing.exceptions.CalcPackage.NotSupported;
import org.apache.tuscany.sca.binding.corba.testing.generated.SimpleStruct;
import org.apache.tuscany.sca.binding.corba.testing.generated.SomeStruct;
import org.apache.tuscany.sca.binding.corba.testing.hierarchy.ArraysTestStruct;
import org.apache.tuscany.sca.binding.corba.testing.hierarchy.DummyObject;
import org.apache.tuscany.sca.binding.corba.testing.hierarchy.InnerUnion;
import org.apache.tuscany.sca.binding.corba.testing.hierarchy.InvalidCorbaArray;
import org.apache.tuscany.sca.binding.corba.testing.hierarchy.InvalidEnum1;
import org.apache.tuscany.sca.binding.corba.testing.hierarchy.InvalidEnum2;
import org.apache.tuscany.sca.binding.corba.testing.hierarchy.InvalidEnum3;
import org.apache.tuscany.sca.binding.corba.testing.hierarchy.InvalidStruct1;
import org.apache.tuscany.sca.binding.corba.testing.hierarchy.InvalidStruct2;
import org.apache.tuscany.sca.binding.corba.testing.hierarchy.InvalidStruct3;
import org.apache.tuscany.sca.binding.corba.testing.hierarchy.InvalidUnion1;
import org.apache.tuscany.sca.binding.corba.testing.hierarchy.InvalidUnion2;
import org.apache.tuscany.sca.binding.corba.testing.hierarchy.InvalidUnion3;
import org.apache.tuscany.sca.binding.corba.testing.hierarchy.InvalidUnion4;
import org.apache.tuscany.sca.binding.corba.testing.hierarchy.InvalidUnion5;
import org.apache.tuscany.sca.binding.corba.testing.hierarchy.RichUnion;
import org.apache.tuscany.sca.binding.corba.testing.servants.ArraysSetterServant;
import org.apache.tuscany.sca.binding.corba.testing.servants.ArraysUnionsServant;
import org.apache.tuscany.sca.binding.corba.testing.servants.ArraysUnionsTuscanyServant;
import org.apache.tuscany.sca.binding.corba.testing.servants.CalcServant;
import org.apache.tuscany.sca.binding.corba.testing.servants.EnumManagerServant;
import org.apache.tuscany.sca.binding.corba.testing.servants.ObjectManagerServant;
import org.apache.tuscany.sca.binding.corba.testing.servants.PrimitivesSetterServant;
import org.apache.tuscany.sca.binding.corba.testing.servants.TestObjectServant;
import org.apache.tuscany.sca.host.corba.naming.TransientNameServer;
import org.apache.tuscany.sca.host.corba.naming.TransientNameService;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import org.omg.CORBA.ORB;
import org.omg.CORBA.Object;
import org.omg.CosNaming.NameComponent;
import org.omg.CosNaming.NamingContext;
import org.omg.CosNaming.NamingContextExt;
import org.omg.CosNaming.NamingContextExtHelper;
import org.omg.CosNaming.NamingContextHelper;

/**
 * @version $Rev$ $Date$
 *          Tests API for dynamic CORBA requests. Tests handling various Java
 *          types.
 */
public class CorbaTypesTestCase {
    private static TransientNameServer server;
    private static ORB orb;

    private static Object refPrimitivesSetter;
    private static Object refArraysSetter;
    private static Object refTestObject;
    private static Object refCalcObject;
    private static Object refObjectManager;
    private static Object refEnumManager;
    private static Object refArraysUnions;

    /**
     * Spawns tnameserv process (must be in PATH). Initializes test servants and
     * stores it's references so tests can use it.
     */
    @BeforeClass
    public static void setUp() {
        try {
            try {
                server =
                    new TransientNameServer(TestConstants.TEST1_HOST, TestConstants.TEST1_PORT,
                                            TransientNameService.DEFAULT_SERVICE_NAME);
                Thread t = server.start();
                if (t == null) {
                    Assert.fail("The naming server cannot be started");
                }
                orb = server.getORB();
            } catch (Throwable e) {
                e.printStackTrace();
                Assert.fail(e.getMessage());
            }

            Object nameService = orb.resolve_initial_references("NameService");
            NamingContext namingContext = NamingContextHelper.narrow(nameService);

            PrimitivesSetterServant singleSetter = new PrimitivesSetterServant();
            ArraysSetterServant arraysSetter = new ArraysSetterServant();
            TestObjectServant complexObject = new TestObjectServant();
            CalcServant calcObject = new CalcServant();
            ObjectManagerServant objectManager = new ObjectManagerServant();
            EnumManagerServant enumManager = new EnumManagerServant();
            ArraysUnionsServant arraysUnions = new ArraysUnionsServant();

            orb.connect(singleSetter);
            orb.connect(arraysSetter);

            NameComponent nc;
            NameComponent[] path;

            nc = new NameComponent("PrimitivesSetter", "");
            path = new NameComponent[] {nc};
            namingContext.rebind(path, singleSetter);

            nc = new NameComponent("ArraysSetter", "");
            path = new NameComponent[] {nc};
            namingContext.rebind(path, arraysSetter);

            nc = new NameComponent("TestObject", "");
            path = new NameComponent[] {nc};
            namingContext.rebind(path, complexObject);

            nc = new NameComponent("CalcObject", "");
            path = new NameComponent[] {nc};
            namingContext.rebind(path, calcObject);

            nc = new NameComponent("ObjectManager", "");
            path = new NameComponent[] {nc};
            namingContext.rebind(path, objectManager);

            nc = new NameComponent("EnumManager", "");
            path = new NameComponent[] {nc};
            namingContext.rebind(path, enumManager);

            nc = new NameComponent("ArraysUnions", "");
            path = new NameComponent[] {nc};
            namingContext.rebind(path, arraysUnions);

            NamingContextExt nce = NamingContextExtHelper.narrow(orb.resolve_initial_references("NameService"));

            refArraysSetter = nce.resolve(nce.to_name("ArraysSetter"));
            refPrimitivesSetter = nce.resolve(nce.to_name("PrimitivesSetter"));
            refTestObject = nce.resolve(nce.to_name("TestObject"));
            refCalcObject = nce.resolve(nce.to_name("CalcObject"));
            refObjectManager = nce.resolve(nce.to_name("ObjectManager"));
            refEnumManager = nce.resolve(nce.to_name("EnumManager"));
            refArraysUnions = nce.resolve(nce.to_name("ArraysUnions"));

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @AfterClass
    public static void stop() {
        server.stop();
    }

    /**
     * Tests remote operation, basing on given reference, operation name,
     * arguments, expected return type and content
     * 
     * @param ref remote object
     * @param operationName operation to invoke
     * @param clazz expected return type
     * @param arguments array of operation arguments
     * @param equalTo expected return content
     */
    private void dynaTestInvoker(Object ref,
                                 String operationName,
                                 Class<?> clazz,
                                 java.lang.Object[] arguments,
                                 java.lang.Object equalTo) {

        try {
            DynaCorbaRequest request = new DynaCorbaRequest(ref, operationName);
            request.setOutputType(clazz);
            for (int i = 0; arguments != null && i < arguments.length; i++) {
                request.addArgument(arguments[i]);
            }

            DynaCorbaResponse response = request.invoke();
            java.lang.Object content = (java.lang.Object)response.getContent();
            assertTrue(content.getClass().equals(clazz));
            if (equalTo != null && equalTo.getClass().isArray()) {
                for (int i = 0; i < Array.getLength(equalTo); i++) {
                    assertTrue(Array.get(content, i).equals(Array.get(equalTo, i)));
                }
            } else {
                assertTrue(content.equals(equalTo));
            }
        } catch (Exception e) {
            e.printStackTrace();
            fail("Error while invoking " + operationName);
        }
    }

    /**
     * Tests passing (and getting as result) varied primitives
     */
    @Test
    public void test_setPrimitives() {

        dynaTestInvoker(refPrimitivesSetter, "setBoolean", Boolean.class, new Boolean[] {true}, true);
        dynaTestInvoker(refPrimitivesSetter, "setOctet", Byte.class, new Byte[] {1}, (byte)1);
        dynaTestInvoker(refPrimitivesSetter, "setChar", Character.class, new Character[] {'A'}, 'A');
        dynaTestInvoker(refPrimitivesSetter, "setShort", Short.class, new Short[] {1}, (short)1);
        dynaTestInvoker(refPrimitivesSetter, "setLong", Integer.class, new Integer[] {1}, (int)1);
        dynaTestInvoker(refPrimitivesSetter, "setLongLong", Long.class, new Long[] {(long)1}, (long)1);
        dynaTestInvoker(refPrimitivesSetter, "setFloat", Float.class, new Float[] {(float)1}, (float)1);
        dynaTestInvoker(refPrimitivesSetter, "setDouble", Double.class, new Double[] {(double)1}, (double)1);
        dynaTestInvoker(refPrimitivesSetter, "setString", String.class, new String[] {"1"}, "1");

    }

    /**
     * Tests passing (and getting as result) varied types sequences
     */
    @Test
    public void test_setArrays() {

        dynaTestInvoker(refArraysSetter,
                        "setBoolean",
                        Boolean[].class,
                        new Boolean[][] {new Boolean[] {false, true}},
                        new Boolean[] {false, true});

        dynaTestInvoker(refArraysSetter,
                        "setChar",
                        Character[].class,
                        new Character[][] {new Character[] {'A', 'B'}},
                        new Character[] {'A', 'B'});

        dynaTestInvoker(refArraysSetter, "setOctet", Byte[].class, new Byte[][] {new Byte[] {1, 2}}, new Byte[] {1, 2});

        dynaTestInvoker(refArraysSetter, "setShort", Short[].class, new Short[][] {new Short[] {1, 2}}, new Short[] {1,
                                                                                                                     2});

        dynaTestInvoker(refArraysSetter,
                        "setLong",
                        Integer[].class,
                        new Integer[][] {new Integer[] {1, 2}},
                        new Integer[] {1, 2});

        dynaTestInvoker(refArraysSetter,
                        "setLongLong",
                        Long[].class,
                        new Long[][] {new Long[] {new Long(1), new Long(2)}},
                        new Long[] {new Long(1), new Long(2)});

        dynaTestInvoker(refArraysSetter,
                        "setFloat",
                        Float[].class,
                        new Float[][] {new Float[] {new Float(1.0), new Float(2.0)}},
                        new Float[] {new Float(1.0), new Float(2.0)});

        dynaTestInvoker(refArraysSetter,
                        "setDouble",
                        Double[].class,
                        new Double[][] {new Double[] {new Double(1.0), new Double(2.0)}},
                        new Double[] {new Double(1.0), new Double(2.0)});

        dynaTestInvoker(refArraysSetter,
                        "setString",
                        String[].class,
                        new String[][] {new String[] {"A", "B"}},
                        new String[] {"A", "B"});

    }

    /**
     * Tests passing (and getting as result) complex structure
     */
    @Test
    public void test_TestObject_setStruct() {
        DynaCorbaRequest request = new DynaCorbaRequest(refTestObject, "setStruct");

        SomeStruct struct = new SomeStruct();
        SimpleStruct inner = new SimpleStruct();
        inner.field1 = TestConstants.STR_1;
        inner.field2 = TestConstants.INT_1;
        struct.innerStruct = inner;
        struct.str_list = TestConstants.STR_ARR_2;
        struct.twoDimSeq = TestConstants.INT_ARRAY_2_DIM;
        struct.threeDimSeq = TestConstants.INT_ARRAY_3_DIM;
        struct.str = TestConstants.STR_1;

        try {
            request.addArgument(struct);
            request.setOutputType(SomeStruct.class);
            DynaCorbaResponse response = request.invoke();
            SomeStruct result = (SomeStruct)response.getContent();
            assertTrue(TestConstants.are2DimArraysEqual(result.twoDimSeq, TestConstants.INT_ARRAY_2_DIM));
            assertTrue(TestConstants.are3DimArraysEqual(result.threeDimSeq, TestConstants.INT_ARRAY_3_DIM));
            assertEquals(TestConstants.STR_1, result.str);
            assertEquals(TestConstants.STR_ARR_2[0], result.str_list[0]);
            assertEquals(TestConstants.STR_ARR_2[1], result.str_list[1]);
            assertEquals(TestConstants.STR_1, result.innerStruct.field1);
            assertEquals(TestConstants.INT_1, result.innerStruct.field2);
        } catch (Exception e) {
            e.printStackTrace();
            fail("Exception occured during tests: " + e);
        }
    }

    /**
     * Test passing (and getting as result) simple two-field structure
     */
    @Test
    public void test_TestObject_setSimpleStruct() {
        SimpleStruct struct = new SimpleStruct();
        struct.field1 = TestConstants.STR_1;
        struct.field2 = TestConstants.INT_1;
        DynaCorbaRequest request = new DynaCorbaRequest(refTestObject, "setSimpleStruct");
        try {
            request.setOutputType(SimpleStruct.class);
            request.addArgument(struct);
            DynaCorbaResponse response = request.invoke();
            SimpleStruct retStruct = (SimpleStruct)response.getContent();
            assertTrue(retStruct.field1.equals(struct.field1) && retStruct.field2 == struct.field2);
        } catch (Exception e) {
            e.printStackTrace();
            fail("Exception occured during tests: " + e);
        }
    }

    /**
     * Tests passing (and getting as result) two dim. sequence of long.
     */
    @Test
    public void test_TestObject_setLongSeq2() {
        int[][] arr1 = new int[2][2];
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                arr1[i][j] = (int)(Math.random() * 1000);
            }
        }
        DynaCorbaRequest request = new DynaCorbaRequest(refTestObject, "setLongSeq2");
        try {
            request.setOutputType(arr1.getClass());
            request.addArgument(arr1);
            DynaCorbaResponse response = request.invoke();
            int[][] arr2 = (int[][])response.getContent();
            for (int i = 0; i < 2; i++) {
                for (int j = 0; j < 2; j++) {
                    assertEquals(arr1[i][j], arr2[i][j]);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            fail("Exception occured during tests: " + e);
        }
    }

    /**
     * Tests passing multiple complex attributes.
     */
    @Test
    public void test_TestObject_pickStructFromArgs() {
        SomeStruct arg1 = new SomeStruct();
        SomeStruct arg2 = new SomeStruct();
        SomeStruct arg3 = new SomeStruct();

        SimpleStruct inner = new SimpleStruct();
        inner.field1 = TestConstants.STR_1;
        inner.field2 = TestConstants.INT_1;

        arg1.innerStruct = inner;
        arg2.innerStruct = inner;
        arg3.innerStruct = inner;

        arg1.str = TestConstants.STR_1;
        arg2.str = TestConstants.STR_2;
        arg3.str = TestConstants.STR_3;

        arg1.str_list = TestConstants.STR_ARR_1;
        arg2.str_list = TestConstants.STR_ARR_2;
        arg3.str_list = TestConstants.STR_ARR_2;

        arg1.threeDimSeq = TestConstants.INT_ARRAY_3_DIM;
        arg2.threeDimSeq = TestConstants.INT_ARRAY_3_DIM;
        arg3.threeDimSeq = TestConstants.INT_ARRAY_3_DIM;

        arg1.twoDimSeq = TestConstants.INT_ARRAY_2_DIM;
        arg2.twoDimSeq = TestConstants.INT_ARRAY_2_DIM;
        arg3.twoDimSeq = TestConstants.INT_ARRAY_2_DIM;

        DynaCorbaRequest request = new DynaCorbaRequest(refTestObject, "pickStructFromArgs");
        try {

            request.setOutputType(SomeStruct.class);
            request.addArgument(arg1);
            request.addArgument(arg2);
            request.addArgument(arg3);
            request.addArgument(1);
            DynaCorbaResponse response = request.invoke();
            SomeStruct result = (SomeStruct)response.getContent();

            // just make sure that servant returned right structure
            assertTrue(result.str.equals(TestConstants.STR_1));
        } catch (Exception e) {
            fail("Exception occured during tests " + e);
            e.printStackTrace();
        }

    }

    /**
     * Tests handling user defined remote exception (single declared)
     */
    @Test
    public void test_singleException() {
        DynaCorbaRequest request1 = new DynaCorbaRequest(refCalcObject, "div");
        try {
            request1.addArgument(2d);
            request1.addArgument(2d);
            request1.setOutputType(Double.class);
            request1.addExceptionType(DivByZero.class);
            request1.invoke();
        } catch (Exception e) {
            fail();
        }

        DynaCorbaRequest request2 = new DynaCorbaRequest(refCalcObject, "div");
        try {
            request2.addArgument(2d);
            request2.addArgument(0d);
            request2.setOutputType(Double.class);
            request2.addExceptionType(DivByZero.class);
            request2.invoke();
        } catch (DivByZero e) {
            assertTrue(e.info != null && e.arguments != null && e.arguments.arg1 == 2 && e.arguments.arg2 == 0);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail();
        }
    }

    /**
     * Tests handling user defined multiple exceptions
     */
    @Test
    public void test_multipleExceptions() {
        DynaCorbaRequest request = new DynaCorbaRequest(refCalcObject, "divForSmallArgs");
        try {
            request.addArgument(101d);
            request.addArgument(101d);
            request.setOutputType(Double.class);
            request.addExceptionType(DivByZero.class);
            request.addExceptionType(NotSupported.class);
            request.invoke();
        } catch (Exception e) {
            assertTrue(e instanceof NotSupported);
        }
    }

    /**
     * Tests handling exceptions while user defined no exceptions
     */
    @Test
    public void test_noExceptionsDeclared() {
        DynaCorbaRequest request = new DynaCorbaRequest(refCalcObject, "div");
        try {
            request.addArgument(1d);
            request.addArgument(0d);
            request.setOutputType(Double.class);
            request.invoke();
            fail();
        } catch (Exception e) {
            assertTrue(e instanceof RequestConfigurationException);
        }
    }

    /**
     * Tests handling exceptions while user defined no such exception
     */
    @Test
    public void test_noSuchExceptionDeclared() {
        DynaCorbaRequest request = new DynaCorbaRequest(refCalcObject, "div");
        try {
            request.addArgument(1d);
            request.addArgument(0d);
            request.addExceptionType(NotSupported.class);
            request.setOutputType(Double.class);
            request.invoke();
            fail();
        } catch (Exception e) {
            assertTrue(e instanceof RequestConfigurationException);
        }
    }

    /**
     * Tests handling non existing operation situation
     */
    @Test
    public void test_systemException_BAD_OPERATION() {
        DynaCorbaRequest request = new DynaCorbaRequest(refCalcObject, "thisOperationSurelyDoesNotExist");
        try {
            request.invoke();
            fail();
        } catch (Exception e) {
            assertTrue(e instanceof CorbaException);
        }
    }

    /**
     * Tests obtaining references to other objects and using them with specified
     * user interface
     */
    @Test
    @Ignore("Cause of tnameservice hang on stop")
    public void test_enchancedReferences() {
        DynaCorbaRequest request = null;
        try {
            request = new DynaCorbaRequest(refObjectManager, "getDummyObject");
            request.setOutputType(DummyObject.class);
            DynaCorbaResponse response = request.invoke();
            DummyObject dummy = (DummyObject)response.getContent();
            DummyObject dummy2 = dummy.cloneObject();
            dummy2.cloneObject();
            assertNotSame(dummy.getLong(), dummy2.getLong());
        } catch (Exception e) {
            e.printStackTrace();
            fail();
        }
    }

    /**
     * Test passing enums as arguments and retrieving them as a result
     */
    @Test
    public void test_enums() {
        try {
            DynaCorbaRequest request = new DynaCorbaRequest(refEnumManager, "getColor");
            Color color = Color.green;
            request.addArgument(color);
            request.setOutputType(Color.class);
            DynaCorbaResponse response = request.invoke();
            Color result = (Color)response.getContent();
            assertEquals(color.value(), result.value());
        } catch (Exception e) {
            e.printStackTrace();
            fail();
        }
    }

    /**
     * Tests recognizing structures
     */
    @Test
    public void test_structValidation() {
        DynaCorbaRequest request = null;
        try {
            request = new DynaCorbaRequest(refArraysSetter, "whatever");
            request.setOutputType(InvalidStruct1.class);
            fail();
        } catch (Exception e) {
            assertTrue(e instanceof RequestConfigurationException);
        }

        try {
            request = new DynaCorbaRequest(refArraysSetter, "whatever");
            request.setOutputType(InvalidStruct2.class);
            fail();
        } catch (Exception e) {
            assertTrue(e instanceof RequestConfigurationException);
        }

        try {
            request = new DynaCorbaRequest(refArraysSetter, "whatever");
            request.setOutputType(InvalidStruct3.class);
            fail();
        } catch (Exception e) {
            assertTrue(e instanceof RequestConfigurationException);
        }

        try {
            request = new DynaCorbaRequest(refArraysSetter, "whatever");
            request.setOutputType(SomeStruct.class);
        } catch (Exception e) {
            fail();
        }
    }

    /**
     * Tests recognizing enums
     */
    @Test
    public void test_enumValidation() {
        DynaCorbaRequest request = null;
        try {
            request = new DynaCorbaRequest(refArraysSetter, "whatever");
            request.setOutputType(InvalidEnum1.class);
            fail();
        } catch (Exception e) {
            assertTrue(e instanceof RequestConfigurationException);
        }

        try {
            request = new DynaCorbaRequest(refArraysSetter, "whatever");
            request.setOutputType(InvalidEnum2.class);
            fail();
        } catch (Exception e) {
            assertTrue(e instanceof RequestConfigurationException);
        }

        try {
            request = new DynaCorbaRequest(refArraysSetter, "whatever");
            request.setOutputType(InvalidEnum3.class);
            fail();
        } catch (Exception e) {
            assertTrue(e instanceof RequestConfigurationException);
        }

        try {
            request = new DynaCorbaRequest(refArraysSetter, "whatever");
            request.setOutputType(Color.class);
        } catch (Exception e) {
            fail();
        }
    }

    /**
     * Tests handling passing wrong params
     */
    @Test
    public void test_systemException_BAD_PARAM() {
        try {
            DynaCorbaRequest request = new DynaCorbaRequest(refCalcObject, "div");
            request.setOutputType(Double.class);
            request.addArgument(3d);
            request.invoke();
            fail();
        } catch (Exception e) {
            if (e instanceof CorbaException) {
                assertTrue(true);
            } else {
                e.printStackTrace();
                fail();
            }
        }
    }

    /**
     * Tests passing CORBA arrays
     */
    @Test
    public void test_arraysPassing() {
        try {
            DynaCorbaRequest request = new DynaCorbaRequest(refArraysUnions, "passStringArray");
            Annotation[] notes =
                ArraysUnionsTuscanyServant.class.getMethod("passStringArray", new Class<?>[] {String[][].class})
                    .getAnnotations();
            request.setOutputType(String[][].class, notes);
            String[][] argument = { {"Hello", "World"}, {"Hi", "again"}};
            request.addArgument(argument, notes);
            DynaCorbaResponse response = request.invoke();
            String[][] result = (String[][])response.getContent();
            for (int i = 0; i < argument.length; i++) {
                for (int j = 0; j < argument[i].length; j++) {
                    assertEquals(argument[i][j], result[i][j]);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            fail();
        }

        try {
            DynaCorbaRequest request = new DynaCorbaRequest(refArraysUnions, "passTestStruct");
            ArraysTestStruct arg = new ArraysTestStruct();
            String[] field1 = {"Hello", "World"};
            arg.field1 = field1;
            int[][] field2 = { {4, 2, 2, 5}, {6, 12, 5, 8}};
            arg.field2 = field2;
            float[][][] field3 = { { {2, 6}, {2, 7}, {9, 3}, {4, 6}}, { {3, 7}, {6, 6}, {3, 5}, {6, 2}}};
            arg.field3 = field3;
            request.addArgument(arg);
            request.setOutputType(ArraysTestStruct.class);
            DynaCorbaResponse response = request.invoke();
            ArraysTestStruct result = (ArraysTestStruct)response.getContent();
            for (int i = 0; i < arg.field1.length; i++) {
                assertEquals(arg.field1[i], result.field1[i]);
            }
            for (int i = 0; i < arg.field2.length; i++) {
                for (int j = 0; j < arg.field2[i].length; j++) {
                    assertEquals(arg.field2[i][j], result.field2[i][j]);
                }
            }
            for (int i = 0; i < arg.field2.length; i++) {
                for (int j = 0; j < arg.field2[i].length; j++) {
                    for (int k = 0; k < arg.field3[i][j].length; k++) {
                        assertEquals(arg.field3[i][j][k], result.field3[i][j][k], 0.0);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            fail();
        }
    }

    /**
     * Tests situation when CORBA array dimension size doesn't match
     * CORBA array annotation arguments (which sets dimension lengths)
     */
    @Test
    public void test_invalidArrayAnnotationSize() {
        try {
            DynaCorbaRequest request = new DynaCorbaRequest(refArraysUnions, "passStringArray");
            Annotation[] notes =
                ArraysUnionsTuscanyServant.class.getMethod("passStringArray", new Class<?>[] {String[][].class})
                    .getAnnotations();
            request.setOutputType(String[][][].class, notes);
            fail();
        } catch (RequestConfigurationException e) {
            // expected
        } catch (Exception e) {
            e.printStackTrace();
            fail();
        }
        try {
            DynaCorbaRequest request = new DynaCorbaRequest(refArraysUnions, "passStringArray");
            Annotation[] notes =
                ArraysUnionsTuscanyServant.class.getMethod("passStringArray", new Class<?>[] {String[][].class})
                    .getAnnotations();
            request.addArgument(new String[0][0][0], notes);
            fail();
        } catch (RequestConfigurationException e) {
            // expected
        } catch (Exception e) {
            e.printStackTrace();
            fail();
        }
        try {
            DynaCorbaRequest request = new DynaCorbaRequest(refArraysUnions, "passStringArray");
            request.addArgument(new InvalidCorbaArray(), null);
            fail();
        } catch (RequestConfigurationException e) {
            // expected
        } catch (Exception e) {
            e.printStackTrace();
            fail();
        }
    }
    
    /**
     * Tests passing CORBA unions
     */
    @Test
    public void test_passingUnions() {
        try {
            DynaCorbaRequest request = new DynaCorbaRequest(refArraysUnions, "passRichUnion");
            request.setOutputType(RichUnion.class);
            RichUnion arg = new RichUnion();
            InnerUnion argIu = new InnerUnion();
            argIu.setX(10);
            arg.setIu(argIu);
            request.addArgument(arg);
            DynaCorbaResponse response = request.invoke();
            RichUnion result = (RichUnion)response.getContent();
            assertEquals(arg.getIu().getX(), result.getIu().getX());
        } catch (Exception e) {
            e.printStackTrace();
            fail();
        }
        try {
            DynaCorbaRequest request = new DynaCorbaRequest(refArraysUnions, "passRichUnion");
            request.setOutputType(RichUnion.class);
            RichUnion arg = new RichUnion();
            arg.setDef(true);
            request.addArgument(arg);
            DynaCorbaResponse response = request.invoke();
            RichUnion result = (RichUnion)response.getContent();
            assertEquals(arg.isDef(), result.isDef());
        } catch (Exception e) {
            e.printStackTrace();
            fail();
        }
    }
    
    /**
     * Tests handling invalid union declarations
     */
    @Test
    public void test_testInvalidUnionClasses() {
        try {
            DynaCorbaRequest request = new DynaCorbaRequest(refArraysUnions, "whatever");
            request.setOutputType(InvalidUnion1.class);
        } catch (Exception e) {
            assertEquals(RequestConfigurationException.class, e.getClass());
        }
        try {
            DynaCorbaRequest request = new DynaCorbaRequest(refArraysUnions, "whatever");
            request.setOutputType(InvalidUnion2.class);
        } catch (Exception e) {
            assertEquals(RequestConfigurationException.class, e.getClass());
        }
        try {
            DynaCorbaRequest request = new DynaCorbaRequest(refArraysUnions, "whatever");
            request.setOutputType(InvalidUnion3.class);
        } catch (Exception e) {
            assertEquals(RequestConfigurationException.class, e.getClass());
        }
        try {
            DynaCorbaRequest request = new DynaCorbaRequest(refArraysUnions, "whatever");
            request.setOutputType(InvalidUnion4.class);
        } catch (Exception e) {
            assertEquals(RequestConfigurationException.class, e.getClass());
        }
        try {
            DynaCorbaRequest request = new DynaCorbaRequest(refArraysUnions, "whatever");
            request.setOutputType(InvalidUnion5.class);
        } catch (Exception e) {
            assertEquals(RequestConfigurationException.class, e.getClass());
        }
    }
}