AbstractTypeTestClient5.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.cxf.systest.type_test;

import java.util.Arrays;
import java.util.List;

import javax.xml.ws.Holder;

import org.apache.type_test.types1.ComplexRestriction;
import org.apache.type_test.types1.ComplexRestriction2;
import org.apache.type_test.types1.ComplexRestriction3;
import org.apache.type_test.types1.ComplexRestriction4;
import org.apache.type_test.types1.ComplexRestriction5;
import org.apache.type_test.types1.FixedArray;
import org.apache.type_test.types1.MixedArray;
import org.apache.type_test.types1.MixedArray.Array10;
import org.apache.type_test.types1.MixedArray.Array9;
import org.apache.type_test.types1.UnboundedArray;
import org.junit.Test;

public abstract class AbstractTypeTestClient5 extends AbstractTypeTestClient4 {

    //org.apache.type_test.types1.ComplexRestriction

    @Test
    public void testComplexRestriction() throws Exception {
        if (!shouldRunTest("ComplexRestriction")) {
            return;
        }
        // normal case, maxLength=10
        ComplexRestriction x = new ComplexRestriction();
        x.setValue("str_x");
        ComplexRestriction yOrig = new ComplexRestriction();
        yOrig.setValue("string_yyy");
        Holder<ComplexRestriction> y = new Holder<ComplexRestriction>(yOrig);
        Holder<ComplexRestriction> z = new Holder<ComplexRestriction>();

        ComplexRestriction ret;
        if (testDocLiteral) {
            ret = docClient.testComplexRestriction(x, y, z);
        } else if (testXMLBinding) {
            ret = xmlClient.testComplexRestriction(x, y, z);
        } else {
            ret = rpcClient.testComplexRestriction(x, y, z);
        }
        if (!perfTestOnly) {
            assertEquals("testComplexRestriction(): Incorrect value for inout param",
                         x.getValue(), y.value.getValue());
            assertEquals("testComplexRestriction(): Incorrect value for out param",
                         yOrig.getValue(), z.value.getValue());
            assertEquals("testComplexRestriction(): Incorrect return value",
                         x.getValue(), ret.getValue());
        }

        // abnormal case
        if (testDocLiteral || testXMLBinding) {
            try {
                x = new ComplexRestriction();
                x.setValue("string_x");
                yOrig = new ComplexRestriction();
                yOrig.setValue("string_yyyyyy");
                y = new Holder<ComplexRestriction>(yOrig);
                z = new Holder<ComplexRestriction>();

                ret = testDocLiteral ? docClient.testComplexRestriction(x, y, z)
                        : xmlClient.testComplexRestriction(x, y, z);
                fail("maxLength=10 restriction is violated.");
            } catch (Exception ex) {
                //ex.printStackTrace();
            }
        }
    }

    //org.apache.type_test.types1.ComplexRestriction2

    @Test
    public void testComplexRestriction2() throws Exception {
        if (!shouldRunTest("ComplexRestriction2")) {
            return;
        }
        // normal case, length=10
        ComplexRestriction2 x = new ComplexRestriction2();
        x.setValue("string_xxx");
        ComplexRestriction2 yOrig = new ComplexRestriction2();
        yOrig.setValue("string_yyy");
        Holder<ComplexRestriction2> y = new Holder<ComplexRestriction2>(yOrig);
        Holder<ComplexRestriction2> z = new Holder<ComplexRestriction2>();

        ComplexRestriction2 ret;
        if (testDocLiteral) {
            ret = docClient.testComplexRestriction2(x, y, z);
        } else if (testXMLBinding) {
            ret = xmlClient.testComplexRestriction2(x, y, z);
        } else {
            ret = rpcClient.testComplexRestriction2(x, y, z);
        }
        if (!perfTestOnly) {
            assertEquals("testComplexRestriction2(): Incorrect value for inout param",
                         x.getValue(), y.value.getValue());
            assertEquals("testComplexRestriction2(): Incorrect value for out param",
                         yOrig.getValue(), z.value.getValue());
            assertEquals("testComplexRestriction2(): Incorrect return value",
                         x.getValue(), ret.getValue());
        }

        // abnormal case
        if (testDocLiteral || testXMLBinding) {
            try {
                x = new ComplexRestriction2();
                x.setValue("str_x");
                yOrig = new ComplexRestriction2();
                yOrig.setValue("string_yyy");
                y = new Holder<ComplexRestriction2>(yOrig);
                z = new Holder<ComplexRestriction2>();

                ret = testDocLiteral ? docClient.testComplexRestriction2(x, y, z)
                        : xmlClient.testComplexRestriction2(x, y, z);
                fail("length=10 restriction is violated.");
            } catch (Exception ex) {
                //ex.printStackTrace();
            }
        }
    }

    //org.apache.type_test.types1.ComplexRestriction3

    @Test
    public void testComplexRestriction3() throws Exception {
        if (!shouldRunTest("ComplexRestriction3")) {
            return;
        }
        // normal case, maxLength=10 for ComplexRestriction
        // && minLength=5 for ComplexRestriction3
        ComplexRestriction3 x = new ComplexRestriction3();
        x.setValue("str_x");
        ComplexRestriction3 yOrig = new ComplexRestriction3();
        yOrig.setValue("string_yyy");
        Holder<ComplexRestriction3> y = new Holder<ComplexRestriction3>(yOrig);
        Holder<ComplexRestriction3> z = new Holder<ComplexRestriction3>();

        ComplexRestriction3 ret;
        if (testDocLiteral) {
            ret = docClient.testComplexRestriction3(x, y, z);
        } else if (testXMLBinding) {
            ret = xmlClient.testComplexRestriction3(x, y, z);
        } else {
            ret = rpcClient.testComplexRestriction3(x, y, z);
        }
        if (!perfTestOnly) {
            assertEquals("testComplexRestriction3(): Incorrect value for inout param",
                         x.getValue(), y.value.getValue());
            assertEquals("testComplexRestriction3(): Incorrect value for out param",
                         yOrig.getValue(), z.value.getValue());
            assertEquals("testComplexRestriction3(): Incorrect return value",
                         x.getValue(), ret.getValue());
        }

        // abnormal cases
        if (testDocLiteral || testXMLBinding) {
            try {
                x = new ComplexRestriction3();
                x.setValue("str");
                y = new Holder<ComplexRestriction3>(yOrig);
                z = new Holder<ComplexRestriction3>();
                ret = testDocLiteral ? docClient.testComplexRestriction3(x, y, z)
                        : xmlClient.testComplexRestriction3(x, y, z);
                fail("maxLength=10 && minLength=5 restriction is violated.");
            } catch (Exception ex) {
                //ex.printStackTrace();
            }
            try {
                x = new ComplexRestriction3();
                x.setValue("string_x");
                yOrig = new ComplexRestriction3();
                yOrig.setValue("string_yyyyyy");
                y = new Holder<ComplexRestriction3>(yOrig);
                z = new Holder<ComplexRestriction3>();
                ret = testDocLiteral ? docClient.testComplexRestriction3(x, y, z)
                        : xmlClient.testComplexRestriction3(x, y, z);
                fail("maxLength=10 && minLength=5 restriction is violated.");
            } catch (Exception ex) {
                //ex.printStackTrace();
            }
        }
    }

    //org.apache.type_test.types1.ComplexRestriction4

    @Test
    public void testComplexRestriction4() throws Exception {
        if (!shouldRunTest("ComplexRestriction4")) {
            return;
        }
        // normal case, maxLength=10 for ComplexRestriction
        // && maxLength=5 for ComplexRestriction4
        ComplexRestriction4 x = new ComplexRestriction4();
        x.setValue("str_x");
        ComplexRestriction4 yOrig = new ComplexRestriction4();
        yOrig.setValue("y");
        Holder<ComplexRestriction4> y = new Holder<ComplexRestriction4>(yOrig);
        Holder<ComplexRestriction4> z = new Holder<ComplexRestriction4>();

        ComplexRestriction4 ret;
        if (testDocLiteral) {
            ret = docClient.testComplexRestriction4(x, y, z);
        } else if (testXMLBinding) {
            ret = xmlClient.testComplexRestriction4(x, y, z);
        } else {
            ret = rpcClient.testComplexRestriction4(x, y, z);
        }
        if (!perfTestOnly) {
            assertEquals("testComplexRestriction4(): Incorrect value for inout param",
                         x.getValue(), y.value.getValue());
            assertEquals("testComplexRestriction4(): Incorrect value for out param",
                         yOrig.getValue(), z.value.getValue());
            assertEquals("testComplexRestriction4(): Incorrect return value",
                         x.getValue(), ret.getValue());
        }

        // abnormal case
        if (testDocLiteral || testXMLBinding) {
            try {
                x = new ComplexRestriction4();
                x.setValue("str_xxx");
                y = new Holder<ComplexRestriction4>(yOrig);
                z = new Holder<ComplexRestriction4>();
                ret = testDocLiteral ? docClient.testComplexRestriction4(x, y, z)
                        : xmlClient.testComplexRestriction4(x, y, z);
                fail("maxLength=5 restriction is violated.");
            } catch (Exception ex) {
                //ex.printStackTrace();
            }
        }
    }

    //org.apache.type_test.types1.ComplexRestriction5
    @Test
    public void testComplexRestriction5() throws Exception {
        if (!shouldRunTest("ComplexRestriction5")) {
            return;
        }
        // normal case, maxLength=50 && minLength=5 for ComplexRestriction5
        ComplexRestriction5 x = new ComplexRestriction5();
        x.setValue("http://www.iona.com");
        ComplexRestriction5 yOrig = new ComplexRestriction5();
        yOrig.setValue("http://www.iona.com/info/services/oss/");
        Holder<ComplexRestriction5> y = new Holder<ComplexRestriction5>(yOrig);
        Holder<ComplexRestriction5> z = new Holder<ComplexRestriction5>();

        ComplexRestriction5 ret;
        if (testDocLiteral) {
            ret = docClient.testComplexRestriction5(x, y, z);
        } else if (testXMLBinding) {
            ret = xmlClient.testComplexRestriction5(x, y, z);
        } else {
            ret = rpcClient.testComplexRestriction5(x, y, z);
        }
        if (!perfTestOnly) {
            assertEquals("testComplexRestriction5(): Incorrect value for inout param",
                         x.getValue(), y.value.getValue());
            assertEquals("testComplexRestriction5(): Incorrect value for out param",
                         yOrig.getValue(), z.value.getValue());
            assertEquals("testComplexRestriction5(): Incorrect return value",
                         x.getValue(), ret.getValue());
        }

        // abnormal cases
        if (testDocLiteral || testXMLBinding) {
            try {
                x = new ComplexRestriction5();
                x.setValue("uri");
                y = new Holder<ComplexRestriction5>(yOrig);
                z = new Holder<ComplexRestriction5>();
                ret = docClient.testComplexRestriction5(x, y, z);
                fail("maxLength=50 && minLength=5 restriction is violated.");
            } catch (Exception ex) {
                //ex.printStackTrace();
            }

            try {
                x = new ComplexRestriction5();
                x.setValue("http://www.iona.com");
                yOrig = new ComplexRestriction5();
                yOrig.setValue("http://www.iona.com/info/services/oss/info_services_oss_train.html");
                y = new Holder<ComplexRestriction5>(yOrig);
                z = new Holder<ComplexRestriction5>();
                ret = testDocLiteral ? docClient.testComplexRestriction5(x, y, z)
                        : xmlClient.testComplexRestriction5(x, y, z);
                fail("maxLength=50 && minLength=5 restriction is violated.");
            } catch (Exception ex) {
                //ex.printStackTrace();
            }
        }
    }

    //org.apache.type_test.types1.MixedArray

    protected boolean equals(MixedArray x, MixedArray y) {
        boolean simpleArraysEqual = x.getArray1().equals(y.getArray1())
            && x.getArray3().equals(y.getArray3())
            && x.getArray5().equals(y.getArray5())
            && x.getArray7().equals(y.getArray7());
        boolean complexArraysEqual = x.getArray2().getItem().equals(y.getArray2().getItem())
            && x.getArray4().getItem().equals(y.getArray4().getItem())
            && x.getArray6().getItem().equals(y.getArray6().getItem())
            && x.getArray8().getItem().equals(y.getArray8().getItem())
            && listsOfArray9equal(x.getArray9(), y.getArray9())
            && listsOfArray10equal(x.getArray10(), y.getArray10());
        return simpleArraysEqual && complexArraysEqual;
    }

    protected boolean listsOfArray9equal(List<Array9> x, List<Array9> y) {
        if ((x == null && y == null) || (x == y)) {
            return true;
        }
        if (x == null || y == null || x.size() != y.size()) {
            return false;
        }
        for (int i = 0; i < x.size(); i++) {
            Array9 a1 = x.get(i);
            Array9 a2 = y.get(i);
            if (a1 == null && a2 == null) {
                continue;
            }
            if (a1 == null || a2 == null) {
                return false;
            }
            if (a1.getItem() == null && a2.getItem() == null) {
                continue;
            }
            if (a1.getItem() == null || a2.getItem() == null) {
                return false;
            }
            if (!a1.getItem().equals(a2.getItem())) {
                return false;
            }
        }
        return true;
    }
    protected boolean listsOfArray10equal(List<Array10> x, List<Array10> y) {
        if ((x == null && y == null) || (x == y)) {
            return true;
        }
        if (x == null || y == null || x.size() != y.size()) {
            return false;
        }
        for (int i = 0; i < x.size(); i++) {
            Array10 a1 = x.get(i);
            Array10 a2 = y.get(i);
            if (a1 == null && a2 == null) {
                continue;
            }
            if (a1 == null || a2 == null) {
                return false;
            }
            if (a1.getItem() == null && a2.getItem() == null) {
                continue;
            }
            if (a1.getItem() == null || a2.getItem() == null) {
                return false;
            }
            if (!a1.getItem().equals(a2.getItem())) {
                return false;
            }
        }
        return true;
    }

    @Test
    public void testMixedArray() throws Exception {
        if (!shouldRunTest("MixedArray")) {
            return;
        }
        MixedArray x = new MixedArray();
        x.getArray1().addAll(Arrays.asList("AAA", "BBB", "CCC"));
        x.setArray2(new UnboundedArray());
        x.getArray2().getItem().addAll(Arrays.asList("aaa", "bbb", "ccc"));
        x.getArray3().addAll(Arrays.asList("DDD", "EEE", "FFF"));
        x.setArray4(new FixedArray());
        x.getArray4().getItem().addAll(Arrays.asList(1, 2, 3));
        x.getArray5().addAll(Arrays.asList("GGG", "HHH", "III"));
        x.setArray6(new MixedArray.Array6());
        x.getArray6().getItem().addAll(Arrays.asList("ggg", "hhh", "iii"));
        x.getArray7().addAll(Arrays.asList("JJJ", "KKK", "LLL"));
        x.setArray8(new MixedArray.Array8());
        x.getArray8().getItem().addAll(Arrays.asList(4, 5, 6));
        Array9 array91 = new MixedArray.Array9();
        Array9 array92 = new MixedArray.Array9();
        Array9 array93 = new MixedArray.Array9();
        array91.setItem("MMM");
        array92.setItem("NNN");
        array93.setItem("OOO");
        x.getArray9().addAll(Arrays.asList(array91, array92, array93));
        Array10 array101 = new MixedArray.Array10();
        Array10 array102 = new MixedArray.Array10();
        Array10 array103 = new MixedArray.Array10();
        array101.setItem("PPP");
        array102.setItem("QQQ");
        array103.setItem("RRR");
        x.getArray10().addAll(Arrays.asList(array101, array102, array103));
        x.getArray11().addAll(Arrays.asList("AAA", "BBB", "CCC"));

        MixedArray yOrig = new MixedArray();
        yOrig.getArray1().addAll(Arrays.asList("XXX", "YYY", "ZZZ"));
        yOrig.setArray2(new UnboundedArray());
        yOrig.getArray2().getItem().addAll(Arrays.asList("xxx", "yyy", "zzz"));
        yOrig.getArray3().addAll(Arrays.asList("DDD", "EEE", "FFF"));
        yOrig.setArray4(new FixedArray());
        yOrig.getArray4().getItem().addAll(Arrays.asList(1, 2, 3));
        yOrig.getArray5().addAll(Arrays.asList("GGG", "HHH", "III"));
        yOrig.setArray6(new MixedArray.Array6());
        yOrig.getArray6().getItem().addAll(Arrays.asList("ggg", "hhh", "iii"));
        yOrig.getArray7().addAll(Arrays.asList("JJJ", "KKK", "LLL"));
        yOrig.setArray8(new MixedArray.Array8());
        yOrig.getArray8().getItem().addAll(Arrays.asList(4, 5, 6));
        array91 = new MixedArray.Array9();
        array92 = new MixedArray.Array9();
        array93 = new MixedArray.Array9();
        array91.setItem("MMM");
        array92.setItem("NNN");
        array93.setItem("OOO");
        yOrig.getArray9().addAll(Arrays.asList(array91, array92, array93));
        array101 = new MixedArray.Array10();
        array102 = new MixedArray.Array10();
        array103 = new MixedArray.Array10();
        array101.setItem("PPP");
        array102.setItem("QQQ");
        array103.setItem("RRR");
        yOrig.getArray10().addAll(Arrays.asList(array101, array102, array103));
        yOrig.getArray11().addAll(Arrays.asList("XXX", "YYY", "ZZZ"));

        Holder<MixedArray> y = new Holder<MixedArray>(yOrig);
        Holder<MixedArray> z = new Holder<MixedArray>();
        MixedArray ret;
        if (testDocLiteral) {
            ret = docClient.testMixedArray(x, y, z);
        } else if (testXMLBinding) {
            ret = xmlClient.testMixedArray(x, y, z);
        } else {
            ret = rpcClient.testMixedArray(x, y, z);
        }
        if (!perfTestOnly) {
            assertTrue("testMixedArray(): Incorrect value for inout param", equals(x, y.value));
            assertTrue("testMixedArray(): Incorrect value for out param", equals(yOrig, z.value));
            assertTrue("testMixedArray(): Incorrect return value", equals(x, ret));
        }

        // checkstyle complained otherwise...
        assertEmptyCollectionsHandled(x, yOrig);
    }

    /**
     * @param x
     * @param yOrig
     */
    private void assertEmptyCollectionsHandled(MixedArray x, MixedArray yOrig) {
        Holder<MixedArray> y;
        Holder<MixedArray> z;
        MixedArray ret;
        // empty collections. may be tested only for sequences, i.e., for lists array1, array2, array5, array6,
        // array9 and array11.
        // array3, array4, array7, array8 and array10 must have 3 elements
        // empty them
        x.getArray1().clear();
        x.setArray2(new UnboundedArray());
        x.getArray5().clear();
        x.setArray6(new MixedArray.Array6());
        x.getArray9().clear();
        x.getArray11().clear();

        // empty them
        yOrig.getArray1().clear();
        yOrig.setArray2(new UnboundedArray());
        yOrig.getArray5().clear();
        yOrig.setArray6(new MixedArray.Array6());
        yOrig.getArray9().clear();
        yOrig.getArray11().clear();

        y = new Holder<MixedArray>(yOrig);
        z = new Holder<MixedArray>();
        if (testDocLiteral) {
            ret = docClient.testMixedArray(x, y, z);
        } else if (testXMLBinding) {
            ret = xmlClient.testMixedArray(x, y, z);
        } else {
            ret = rpcClient.testMixedArray(x, y, z);
        }
        if (!perfTestOnly) {
            assertTrue("testMixedArray(): Incorrect value for inout param", equals(x, y.value));
            assertTrue("testMixedArray(): Incorrect value for out param", equals(yOrig, z.value));
            assertTrue("testMixedArray(): Incorrect return value", equals(x, ret));
        }
    }

}