diff options
Diffstat (limited to 'sca-java-1.x/branches/sca-java-1.3.2/itest/databindings/jaxb-bottom-up/src/test')
5 files changed, 3104 insertions, 0 deletions
diff --git a/sca-java-1.x/branches/sca-java-1.3.2/itest/databindings/jaxb-bottom-up/src/test/java/org/apache/tuscany/sca/itest/databindings/jaxb/DatabindingTestCase.java b/sca-java-1.x/branches/sca-java-1.3.2/itest/databindings/jaxb-bottom-up/src/test/java/org/apache/tuscany/sca/itest/databindings/jaxb/DatabindingTestCase.java new file mode 100644 index 0000000000..4967b896a5 --- /dev/null +++ b/sca-java-1.x/branches/sca-java-1.3.2/itest/databindings/jaxb-bottom-up/src/test/java/org/apache/tuscany/sca/itest/databindings/jaxb/DatabindingTestCase.java @@ -0,0 +1,339 @@ +/* + * 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.itest.databindings.jaxb; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import junit.framework.Assert; + +import org.apache.tuscany.sca.host.embedded.SCADomain; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Test; + +/** + * @version $Rev$ $Date$ + */ +public class DatabindingTestCase { + + private static SCADomain domain; + + /** + * Runs once before running the tests + */ + @BeforeClass + public static void setUp() throws Exception { + try { + domain = SCADomain.newInstance("helloservice.composite"); + } catch(Throwable e) { + e.printStackTrace(); + } + } + + /** + * Runs once after running the tests + */ + @AfterClass + public static void tearDown() { + domain.close(); + } + + /** + * Invokes the HelloServiceSimple service using SCA binding. + * Service method invoked is getGreetings. + */ + @Test + public void testSCA() throws Exception { + HelloServiceSimpleClient helloServiceSimpleClient = domain.getService(HelloServiceSimpleClient.class, "HelloServiceSimpleClientSCAComponent"); + performTest(helloServiceSimpleClient); + } + + /** + * Invokes the HelloServiceSimple service using SCA binding. + * Service method invoked is getGreetingsArray. + */ + @Test + public void testSCAArray() throws Exception { + HelloServiceSimpleClient helloServiceSimpleClient = domain.getService(HelloServiceSimpleClient.class, "HelloServiceSimpleClientSCAComponent"); + performTestArray(helloServiceSimpleClient); + } + + /** + * Invokes the HelloServiceSimple service using SCA binding. + * Service method invoked is getGreetingsList. + */ + @Test + public void testSCAList() throws Exception { + HelloServiceSimpleClient helloServiceSimpleClient = domain.getService(HelloServiceSimpleClient.class, "HelloServiceSimpleClientSCAComponent"); + performTestList(helloServiceSimpleClient); + } + + /** + * Invokes the HelloServiceSimple service using SCA binding. + * Service method invoked is getGreetingsArrayList. + */ + @Test + public void testSCAArrayList() throws Exception { + HelloServiceSimpleClient helloServiceSimpleClient = domain.getService(HelloServiceSimpleClient.class, "HelloServiceSimpleClientSCAComponent"); + performTestArrayList(helloServiceSimpleClient); + } + + /** + * Invokes the HelloServiceSimple service using SCA binding. + * Service method invoked is getGreetingsMap. + */ + @Test + public void testSCAMap() throws Exception { + HelloServiceSimpleClient helloServiceSimpleClient = domain.getService(HelloServiceSimpleClient.class, "HelloServiceSimpleClientSCAComponent"); + performTestMap(helloServiceSimpleClient); + } + + /** + * Invokes the HelloServiceSimple service using SCA binding. + * Service method invoked is getGreetingsHashMap. + */ + @Test + public void testSCAHashMap() throws Exception { + HelloServiceSimpleClient helloServiceSimpleClient = domain.getService(HelloServiceSimpleClient.class, "HelloServiceSimpleClientSCAComponent"); + performTestHashMap(helloServiceSimpleClient); + } + + /** + * Invokes the HelloServiceSimple service using SCA binding. + * Service method invoked is getGreetingsVarArgs. + */ + @Test + public void testSCAVarArgs() throws Exception { + HelloServiceSimpleClient helloServiceSimpleClient = domain.getService(HelloServiceSimpleClient.class, "HelloServiceSimpleClientSCAComponent"); + performTestVarArgs(helloServiceSimpleClient); + } + + /** + * Invokes the HelloServiceSimple service using WS binding. + * Service method invoked is getGreetings. + */ + @Test + public void testWS() throws Exception { + HelloServiceSimpleClient helloServiceSimpleClient = domain.getService(HelloServiceSimpleClient.class, "HelloServiceSimpleClientWSComponent"); + performTest(helloServiceSimpleClient); + } + + /** + * Invokes the HelloServiceSimple service using WS binding. + * Service method invoked is getGreetingsArray. + */ + @Test + public void testWSArray() throws Exception { + HelloServiceSimpleClient helloServiceSimpleClient = domain.getService(HelloServiceSimpleClient.class, "HelloServiceSimpleClientWSComponent"); + performTestArray(helloServiceSimpleClient); + } + + /** + * Invokes the HelloServiceSimple service using WS binding. + * Service method invoked is getGreetingsList. + */ + @Test + public void testWSList() throws Exception { + HelloServiceSimpleClient helloServiceSimpleClient = domain.getService(HelloServiceSimpleClient.class, "HelloServiceSimpleClientWSComponent"); + performTestList(helloServiceSimpleClient); + } + + /** + * Invokes the HelloServiceSimple service using WS binding. + * Service method invoked is getGreetingsArrayList. + */ + @Test + public void testWSArrayList() throws Exception { + HelloServiceSimpleClient helloServiceSimpleClient = domain.getService(HelloServiceSimpleClient.class, "HelloServiceSimpleClientWSComponent"); + performTestArrayList(helloServiceSimpleClient); + } + + /** + * Invokes the HelloServiceSimple service using WS binding. + * Service method invoked is getGreetingsMap. + */ + @Test + public void testWSMap() throws Exception { + HelloServiceSimpleClient helloServiceSimpleClient = domain.getService(HelloServiceSimpleClient.class, "HelloServiceSimpleClientWSComponent"); + performTestMap(helloServiceSimpleClient); + } + + /** + * Invokes the HelloServiceSimple service using WS binding. + * Service method invoked is getGreetingsHashMap. + */ + @Test + public void testWSHashMap() throws Exception { + HelloServiceSimpleClient helloServiceSimpleClient = domain.getService(HelloServiceSimpleClient.class, "HelloServiceSimpleClientWSComponent"); + performTestHashMap(helloServiceSimpleClient); + } + + /** + * Invokes the HelloServiceSimple service using WS binding. + * Service method invoked is getGreetingsVarArgs. + */ + @Test + public void testWSVarArgs() throws Exception { + HelloServiceSimpleClient helloServiceSimpleClient = domain.getService(HelloServiceSimpleClient.class, "HelloServiceSimpleClientWSComponent"); + performTestVarArgs(helloServiceSimpleClient); + } + + /** + * Invokes the HelloLocalServiceSimple service using SCA binding. + * Service method invoked is getGreetings. + */ + @Test + public void testSCALocal() throws Exception { + HelloServiceSimpleClient helloServiceSimpleClient = domain.getService(HelloServiceSimpleClient.class, "HelloLocalServiceSimpleClientSCAComponent"); + performTest(helloServiceSimpleClient); + } + + /** + * Invokes the HelloLocalServiceSimple service using SCA binding. + * Service method invoked is getGreetingsArray. + */ + @Test + public void testSCALocalArray() throws Exception { + HelloServiceSimpleClient helloServiceSimpleClient = domain.getService(HelloServiceSimpleClient.class, "HelloLocalServiceSimpleClientSCAComponent"); + performTestArray(helloServiceSimpleClient); + } + + /** + * Invokes the HelloLocalServiceSimple service using SCA binding. + * Service method invoked is getGreetingsList. + */ + @Test + public void testSCALocalList() throws Exception { + HelloServiceSimpleClient helloServiceSimpleClient = domain.getService(HelloServiceSimpleClient.class, "HelloLocalServiceSimpleClientSCAComponent"); + performTestList(helloServiceSimpleClient); + } + + /** + * Invokes the HelloLocalServiceSimple service using SCA binding. + * Service method invoked is getGreetingsArrayList. + */ + @Test + public void testSCALocalArrayList() throws Exception { + HelloServiceSimpleClient helloServiceSimpleClient = domain.getService(HelloServiceSimpleClient.class, "HelloLocalServiceSimpleClientSCAComponent"); + performTestArrayList(helloServiceSimpleClient); + } + + /** + * Invokes the HelloLocalServiceSimple service using SCA binding. + * Service method invoked is getGreetingsMap. + */ + @Test + public void testSCALocalMap() throws Exception { + HelloServiceSimpleClient helloServiceSimpleClient = domain.getService(HelloServiceSimpleClient.class, "HelloLocalServiceSimpleClientSCAComponent"); + performTestMap(helloServiceSimpleClient); + } + + /** + * Invokes the HelloLocalServiceSimple service using SCA binding. + * Service method invoked is getGreetingsHashMap. + */ + @Test + public void testSCALocalHashMap() throws Exception { + HelloServiceSimpleClient helloServiceSimpleClient = domain.getService(HelloServiceSimpleClient.class, "HelloLocalServiceSimpleClientSCAComponent"); + performTestHashMap(helloServiceSimpleClient); + } + + /** + * Invokes the HelloLocalServiceSimple service using SCA binding. + * Service method invoked is getGreetingsVarArgs. + */ + @Test + public void testSCALocalVarArgs() throws Exception { + HelloServiceSimpleClient helloServiceSimpleClient = domain.getService(HelloServiceSimpleClient.class, "HelloLocalServiceSimpleClientSCAComponent"); + performTestVarArgs(helloServiceSimpleClient); + } + + private void performTest(HelloServiceSimpleClient helloServiceSimpleClient) { + String name = "Pandu"; + String resp = helloServiceSimpleClient.getGreetingsForward(name); + Assert.assertEquals("Hello "+name, resp); + } + + private void performTestArray(HelloServiceSimpleClient helloServiceSimpleClient) { + String[] names = {"Me", "Pandu"}; + String[] resps = helloServiceSimpleClient.getGreetingsArrayForward(names); + for(int i = 0; i < names.length; ++i) { + Assert.assertEquals("Hello "+names[i], resps[i]); + } + } + + private void performTestList(HelloServiceSimpleClient helloServiceSimpleClient) { + List<String> namesList = new ArrayList<String>(); + namesList.add("Me"); + namesList.add("Pandu"); + namesList.add("Chinnipandu"); + List<String> respList = helloServiceSimpleClient.getGreetingsListForward(namesList); + Assert.assertEquals(namesList.size(), respList.size()); + for(int i = 0; i < namesList.size(); ++i) { + Assert.assertEquals("Hello "+namesList.get(i), respList.get(i)); + } + } + + private void performTestArrayList(HelloServiceSimpleClient helloServiceSimpleClient) { + ArrayList<String> namesList = new ArrayList<String>(); + namesList.add("Me"); + namesList.add("Pandu"); + namesList.add("Chinnipandu"); + ArrayList<String> respList = helloServiceSimpleClient.getGreetingsArrayListForward(namesList); + Assert.assertEquals(namesList.size(), respList.size()); + for(int i = 0; i < namesList.size(); ++i) { + Assert.assertEquals("Hello "+namesList.get(i), respList.get(i)); + } + } + + private void performTestMap(HelloServiceSimpleClient helloServiceSimpleClient) { + Map<String, String> namesMap = new HashMap<String, String>(); + namesMap.put("Me", null); + namesMap.put("Pandu", null); + namesMap.put("Chinnipandu", null); + Map<String, String> respMap = helloServiceSimpleClient.getGreetingsMapForward(namesMap); + Assert.assertEquals(namesMap.keySet().size(), respMap.keySet().size()); + for(Map.Entry<String, String> entry: namesMap.entrySet()) { + Assert.assertEquals("Hello "+entry.getKey(), respMap.get(entry.getKey())); + } + } + + private void performTestHashMap(HelloServiceSimpleClient helloServiceSimpleClient) { + HashMap<String, String> namesMap = new HashMap<String, String>(); + namesMap.put("Me", null); + namesMap.put("Pandu", null); + namesMap.put("Chinnipandu", null); + Map<String, String> respMap = helloServiceSimpleClient.getGreetingsHashMapForward(namesMap); + Assert.assertEquals(namesMap.keySet().size(), respMap.keySet().size()); + for(Map.Entry<String, String> entry: namesMap.entrySet()) { + Assert.assertEquals("Hello "+entry.getKey(), respMap.get(entry.getKey())); + } + } + + private void performTestVarArgs(HelloServiceSimpleClient helloServiceSimpleClient) { + String[] names = { "Me", "You", "Pandu" }; // Do not change the array size from 3. + String expected = "Hello Me You Pandu"; + String actual = helloServiceSimpleClient.getGreetingsVarArgsForward(names[0], names[1], names[2]); + Assert.assertEquals(expected, actual); + } +} diff --git a/sca-java-1.x/branches/sca-java-1.3.2/itest/databindings/jaxb-bottom-up/src/test/java/org/apache/tuscany/sca/itest/databindings/jaxb/DocLitBareWsdlTestCase.java b/sca-java-1.x/branches/sca-java-1.3.2/itest/databindings/jaxb-bottom-up/src/test/java/org/apache/tuscany/sca/itest/databindings/jaxb/DocLitBareWsdlTestCase.java new file mode 100644 index 0000000000..744bf20494 --- /dev/null +++ b/sca-java-1.x/branches/sca-java-1.3.2/itest/databindings/jaxb-bottom-up/src/test/java/org/apache/tuscany/sca/itest/databindings/jaxb/DocLitBareWsdlTestCase.java @@ -0,0 +1,67 @@ +/* + * 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.itest.databindings.jaxb; + +import junit.framework.Assert; + +import org.apache.tuscany.sca.host.embedded.SCADomain; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Test; + +/** + * @version $Rev$ $Date$ + */ +public class DocLitBareWsdlTestCase { + + private static SCADomain domain; + + /** + * Runs once before running the tests + */ + @BeforeClass + public static void setUp() throws Exception { + try { + domain = SCADomain.newInstance("doclitbarewsdl.composite"); + } catch (Throwable e) { + // @Ignore("TUSCANY-2398") + e.printStackTrace(); + } + } + + /** + * Runs once after running the tests + */ + @AfterClass + public static void tearDown() { + if (domain != null) { + domain.close(); + } + } + + // @Ignore("TUSCANY-2398") + @Test + public void testDocLitBareWsdl() throws Exception { + AClientService client = domain.getService(AClientService.class, "AClientComponent"); + String name = "Pandu"; + String resp = client.getGreetingsForward(name); + Assert.assertEquals("Hello " + name, resp); + } +} diff --git a/sca-java-1.x/branches/sca-java-1.3.2/itest/databindings/jaxb-bottom-up/src/test/java/org/apache/tuscany/sca/itest/databindings/jaxb/GenericsDatabindingTestCase.java b/sca-java-1.x/branches/sca-java-1.3.2/itest/databindings/jaxb-bottom-up/src/test/java/org/apache/tuscany/sca/itest/databindings/jaxb/GenericsDatabindingTestCase.java new file mode 100644 index 0000000000..c22d00140e --- /dev/null +++ b/sca-java-1.x/branches/sca-java-1.3.2/itest/databindings/jaxb-bottom-up/src/test/java/org/apache/tuscany/sca/itest/databindings/jaxb/GenericsDatabindingTestCase.java @@ -0,0 +1,484 @@ +/* + * 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.itest.databindings.jaxb; + +import junit.framework.Assert; + +import org.apache.tuscany.sca.host.embedded.SCADomain; +import org.apache.tuscany.sca.itest.databindings.jaxb.impl.GenericsTransformer; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Test; + +/** + * Databinding tests for generics, parameterized and polymorphic types. + * + * @version $Rev$ $Date$ + */ +public class GenericsDatabindingTestCase { + private static SCADomain domain; + + /** + * Runs before each test method + */ + @BeforeClass + public static void setUp() throws Exception { + try { + domain = SCADomain.newInstance("generics-service.composite"); + } catch(Throwable e) { + e.printStackTrace(); + } + } + + /** + * Runs after each test method + */ + @AfterClass + public static void tearDown() { + domain.close(); + } + + /** + * Invokes the GenericsService service using SCA binding. + * Service method invoked is getTypeExplicit. + */ + @Test + public void testSCATypeExplicit() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsServiceClientSCAComponent"); + performTestTypeExplicit(serviceClient); + } + + /** + * Invokes the GenericsService service using SCA binding. + * Service method invoked is getTypeUnbound. + */ + @Test + public void testSCATypeUnbound() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsServiceClientSCAComponent"); + performTestTypeUnbound(serviceClient); + } + + /** + * Invokes the GenericsService service using SCA binding. + * Service method invoked is getTypeExtends. + */ + @Test + public void testSCATypeExtends() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsServiceClientSCAComponent"); + performTestTypeExtends(serviceClient); + } + + /** + * Invokes the GenericsService service using SCA binding. + * Service method invoked is getRecursiveTypeBound. + */ + @Test + public void testSCARecursiveTypeBound() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsServiceClientSCAComponent"); + performTestRecursiveTypeBound(serviceClient); + } + + /** + * Invokes the GenericsService service using SCA binding. + * Service method invoked is getWildcardUnbound. + */ + @Test + public void testSCAWildcardUnbound() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsServiceClientSCAComponent"); + performTestWildcardUnbound(serviceClient); + } + + /** + * Invokes the GenericsService service using SCA binding. + * Service method invoked is getWildcardSuper. + */ + @Test + public void testSCAWildcardSuper() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsServiceClientSCAComponent"); + performTestWildcardSuper(serviceClient); + } + + /** + * Invokes the GenericsService service using SCA binding. + * Service method invoked is getWildcardExtends. + */ + @Test + public void testSCAWildcardExtends() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsServiceClientSCAComponent"); + performTestWildcardExtends(serviceClient); + } + + /** + * Invokes the GenericsService service using SCA binding. + * Service method invoked is getPolymorphic. + */ + @Test + public void testSCAPolymorphic() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsServiceClientSCAComponent"); + performTestPolymorphic(serviceClient); + } + + /** + * Invokes the GenericsService service using WS binding. + * Service method invoked is getTypeExplicit. + */ + @Test + public void testWSTypeExplicit() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsServiceClientWSComponent"); + performTestTypeExplicit(serviceClient); + } + + /** + * Invokes the GenericsService service using WS binding. + * Service method invoked is getTypeUnbound. + */ + @Test + public void testWSTypeUnbound() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsServiceClientWSComponent"); + performTestTypeUnbound(serviceClient); + } + + /** + * Invokes the GenericsService service using WS binding. + * Service method invoked is getTypeExtends. + */ + @Test + public void testWSTypeExtends() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsServiceClientWSComponent"); + performTestTypeExtends(serviceClient); + } + + /** + * Invokes the GenericsService service using WS binding. + * Service method invoked is getRecursiveTypeBound. + */ + @Test + public void testWSRecursiveTypeBound() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsServiceClientWSComponent"); + performTestRecursiveTypeBound(serviceClient); + } + + /** + * Invokes the GenericsService service using WS binding. + * Service method invoked is getWildcardUnbound. + */ + @Test + public void testWSWildcardUnbound() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsServiceClientWSComponent"); + performTestWildcardUnbound(serviceClient); + } + + /** + * Invokes the GenericsService service using WS binding. + * Service method invoked is getWildcardSuper. + */ + @Test + public void testWSWildcardSuper() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsServiceClientWSComponent"); + performTestWildcardSuper(serviceClient); + } + + /** + * Invokes the GenericsService service using WS binding. + * Service method invoked is getWildcardExtends. + */ + @Test + public void testWSWildcardExtends() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsServiceClientWSComponent"); + performTestWildcardExtends(serviceClient); + } + + /** + * Invokes the GenericsService service using WS binding. + * Service method invoked is getPolymorphic. + */ + @Test + public void testWSPolymorphic() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsServiceClientWSComponent"); + performTestPolymorphic(serviceClient); + } + + /** + * Invokes the GenericsLocalService service using SCA binding. + * Service method invoked is getTypeExplicit. + */ + @Test + public void testSCALocalTypeExplicit() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsLocalServiceClientSCAComponent"); + performTestTypeExplicit(serviceClient); + } + + /** + * Invokes the GenericsLocalService service using SCA binding. + * Service method invoked is getTypeUnbound. + */ + @Test + public void testSCALocalTypeUnbound() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsLocalServiceClientSCAComponent"); + performTestTypeUnbound(serviceClient); + } + + /** + * Invokes the GenericsLocalService service using SCA binding. + * Service method invoked is getTypeExtends. + */ + @Test + public void testSCALocalTypeExtends() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsLocalServiceClientSCAComponent"); + performTestTypeExtends(serviceClient); + } + + /** + * Invokes the GenericsLocalService service using SCA binding. + * Service method invoked is getRecursiveTypeBound. + */ + @Test + public void testSCALocalRecursiveTypeBound() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsLocalServiceClientSCAComponent"); + performTestRecursiveTypeBound(serviceClient); + } + + /** + * Invokes the GenericsLocalService service using SCA binding. + * Service method invoked is getWildcardUnbound. + */ + @Test + public void testSCALocalWildcardUnbound() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsLocalServiceClientSCAComponent"); + performTestWildcardUnbound(serviceClient); + } + + /** + * Invokes the GenericsLocalService service using SCA binding. + * Service method invoked is getWildcardSuper. + */ + @Test + public void testSCALocalWildcardSuper() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsLocalServiceClientSCAComponent"); + performTestWildcardSuper(serviceClient); + } + + /** + * Invokes the GenericsLocalService service using SCA binding. + * Service method invoked is getWildcardExtends. + */ + @Test + public void testSCALocalWildcardExtends() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsLocalServiceClientSCAComponent"); + performTestWildcardExtends(serviceClient); + } + + /** + * Invokes the GenericsLocalService service using SCA binding. + * Service method invoked is getPolymorphic. + */ + @Test + public void testSCALocalPolymorphic() throws Exception { + GenericsServiceClient serviceClient = domain.getService(GenericsServiceClient.class, "GenericsLocalServiceClientSCAComponent"); + performTestPolymorphic(serviceClient); + } + + private void performTestTypeExplicit(GenericsServiceClient serviceClient) { + Bean1<String> args[] = new Bean1[2]; + args[0] = new Bean1<String>("Me"); + args[1] = new Bean1<String>(); + for(int i = 0; i < args.length; ++i) { + Bean1<String> arg = args[i]; + Bean1<String> expected = GenericsTransformer.getTypeExplicit(arg); + Bean1<String> actual = serviceClient.getTypeExplicitForward(arg); + Assert.assertEquals(expected, actual); + } + } + + private void performTestTypeUnbound(GenericsServiceClient serviceClient) { + { // String + String[] args = { "Me", "You", "Him" }; + Bean1<String> expected = GenericsTransformer.getTypeUnbound(args); + Bean1<String> actual = serviceClient.getTypeUnboundForward(args); + // Assert.assertEquals(expected, actual); + } + { // Integer + Integer[] args = new Integer[3]; + args[0] = -10; + args[1] = 0; + args[2] = 10; + Bean1<Integer> expected = GenericsTransformer.getTypeUnbound(args); + Bean1<Integer> actual = serviceClient.getTypeUnboundForward(args); + // Assert.assertEquals(expected, actual); + } + { // Object + Object[] args = new Object[3]; + args[0] = "Me"; + args[1] = 10; + args[2] = "Him"; + Bean1<Object> expected = GenericsTransformer.getTypeUnbound(args); + Bean1<Object> actual = serviceClient.getTypeUnboundForward(args); + Assert.assertEquals(expected, actual); + } + } + + private void performTestTypeExtends(GenericsServiceClient serviceClient) { + { // Bean2 + Bean2[] args = new Bean2[3]; + for(int i = 0; i < args.length; ++i) { + args[i] = new Bean2(); + args[i].setName("Name"+i); + } + + Bean1<Bean2> expected = GenericsTransformer.getTypeExtends(args); + Bean1<Bean2> actual = serviceClient.getTypeExtendsForward(args); + Assert.assertEquals(expected, actual); + } + { // Bean3 extends Bean2 + Bean3[] args = new Bean3[3]; + for(int i = 0; i < args.length; ++i) { + args[i] = new Bean3(); + args[i].setName("Name"+i); + args[i].setAddress("Address"+i); + } + + Bean1<Bean3> expected = GenericsTransformer.getTypeExtends(args); + Bean1<Bean3> actual = serviceClient.getTypeExtendsForward(args); + // Assert.assertEquals(expected, actual); + } + { //Bean31 extends Bean2 + Bean31[] args = new Bean31[3]; + for(int i = 0; i < args.length; ++i) { + args[i] = new Bean31(); + args[i].setName("Name"+i); + args[i].setAddress("Address"+i); + } + + Bean1<Bean31> expected = GenericsTransformer.getTypeExtends(args); + Bean1<Bean31> actual = serviceClient.getTypeExtendsForward(args); + // Assert.assertEquals(expected, actual); + } + } + + private void performTestRecursiveTypeBound(GenericsServiceClient serviceClient) { + { // Bean1<String> + Bean1<String>[] args = new Bean1[3]; + for(int i = 0; i < args.length; ++i) { + args[i] = new Bean1<String>(); + args[i].setItem("Bean."+i); + } + Bean1<Bean1<String>> expected = GenericsTransformer.getRecursiveTypeBound(args); + Bean1<Bean1<String>> actual = serviceClient.getRecursiveTypeBoundForward(args); + Assert.assertEquals(expected, actual); + } + { // Bean10 extends Bean1<String> + Bean10[] args = new Bean10[3]; + for(int i = 0; i < args.length; ++i) { + args[i] = new Bean10(); + args[i].setItem("Bean10."+i); + } + Bean1<Bean10> expected = GenericsTransformer.getRecursiveTypeBound(args); + Bean1<Bean10> actual = serviceClient.getRecursiveTypeBoundForward(args); + // Assert.assertEquals(expected, actual); + } + { // Bean11 extends Bean1<String> + Bean11[] args = new Bean11[3]; + for(int i = 0; i < args.length; ++i) { + args[i] = new Bean11(); + args[i].setItem("Bean11."+i); + } + Bean1<Bean11> expected = GenericsTransformer.getRecursiveTypeBound(args); + Bean1<Bean11> actual = serviceClient.getRecursiveTypeBoundForward(args); + // Assert.assertEquals(expected, actual); + } + } + + private void performTestWildcardUnbound(GenericsServiceClient serviceClient) { + { + Bean1<?> arg = new Bean1<String>("Me"); + Bean1<?> expected = GenericsTransformer.getWildcardUnbound(arg); + Bean1<?> actual = serviceClient.getWildcardUnboundForward(arg); + Assert.assertEquals(expected, actual); + } + { + Bean1<?> arg = new Bean1<Integer>(1); + Bean1<?> expected = GenericsTransformer.getWildcardUnbound(arg); + Bean1<?> actual = serviceClient.getWildcardUnboundForward(arg); + Assert.assertEquals(expected, actual); + } + } + + private void performTestWildcardSuper(GenericsServiceClient serviceClient) { + Bean1<? super Bean3> arg = new Bean1<Bean2>(); + Bean3 item = new Bean3(); + item.setName("Name"); + item.setAddress("Address"); + arg.setItem(item); + Bean1<? super Bean3> expected = GenericsTransformer.getWildcardSuper(arg); + Bean1<? super Bean3> actual = serviceClient.getWildcardSuperForward(arg); + Assert.assertEquals(expected, actual); + } + + private void performTestWildcardExtends(GenericsServiceClient serviceClient) { + { // Bean2 + Bean2 temp = new Bean2(); + temp.setName("Me"); + Bean1<? extends Bean2> arg = new Bean1<Bean2>(temp); + Bean1<? extends Bean2> expected = GenericsTransformer.getWildcardExtends(arg); + Bean1<? extends Bean2> actual = serviceClient.getWildcardExtendsForward(arg); + Assert.assertEquals(expected, actual); + } + { // Bean3 extends Bean2 + Bean3 temp = new Bean3(); + temp.setName("Me"); + temp.setAddress("My address"); + Bean1<? extends Bean2> arg = new Bean1<Bean3>(temp); + Bean1<? extends Bean2> expected = GenericsTransformer.getWildcardExtends(arg); + Bean1<? extends Bean2> actual = serviceClient.getWildcardExtendsForward(arg); + // The Bean3 will be unmarshalled into Bean2 + // Assert.assertEquals(expected, actual); + Assert.assertTrue(actual.getItem() instanceof Bean2); + } + { // Bean31 extends Bean2 + Bean31 temp = new Bean31(); + temp.setName("Me1"); + temp.setAddress("My address1"); + Bean1<? extends Bean2> arg = new Bean1<Bean31>(temp); + Bean1<? extends Bean2> expected = GenericsTransformer.getWildcardExtends(arg); + Bean1<? extends Bean2> actual = serviceClient.getWildcardExtendsForward(arg); + // The Bean31 will be unmarshalled into Bean2 + // Assert.assertEquals(expected, actual); + Assert.assertTrue(actual.getItem() instanceof Bean2); + } + } + + private void performTestPolymorphic(GenericsServiceClient serviceClient) { + { // Bean2 + Bean2 arg = new Bean2(); + arg.setName("Me"); + Bean2 expected = GenericsTransformer.getPolymorphic(arg); + Bean2 actual = serviceClient.getPolymorphicForward(arg); + Assert.assertEquals(expected, actual); + } + { // Bean3 extends Bean2 + Bean3 arg = new Bean3(); + arg.setName("Me"); + arg.setAddress("My address"); + Bean2 expected = GenericsTransformer.getPolymorphic(arg); + Bean2 actual = serviceClient.getPolymorphicForward(arg); + Assert.assertEquals(expected.getName(), actual.getName()); + } + } +} diff --git a/sca-java-1.x/branches/sca-java-1.3.2/itest/databindings/jaxb-bottom-up/src/test/java/org/apache/tuscany/sca/itest/databindings/jaxb/PrimitivesDatabindingTestCase.java b/sca-java-1.x/branches/sca-java-1.3.2/itest/databindings/jaxb-bottom-up/src/test/java/org/apache/tuscany/sca/itest/databindings/jaxb/PrimitivesDatabindingTestCase.java new file mode 100644 index 0000000000..f8aaad3dac --- /dev/null +++ b/sca-java-1.x/branches/sca-java-1.3.2/itest/databindings/jaxb-bottom-up/src/test/java/org/apache/tuscany/sca/itest/databindings/jaxb/PrimitivesDatabindingTestCase.java @@ -0,0 +1,776 @@ +/* + * 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.itest.databindings.jaxb; + +import junit.framework.Assert; + +import org.apache.tuscany.sca.host.embedded.SCADomain; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Test; + +/** + * @version $Rev$ $Date$ + */ +public class PrimitivesDatabindingTestCase { + + private static SCADomain domain; + + /** + * Runs before each test method + */ + @BeforeClass + public static void setUp() throws Exception { + try { + domain = SCADomain.newInstance("primitivesservice.composite"); + } catch(Throwable e) { + e.printStackTrace(); + Assert.fail(); + } + } + + /** + * Runs after each test method + */ + @AfterClass + public static void tearDown() { + domain.close(); + } + + /** + * Invokes the PrimitivesService service using SCA binding. + * Service method invoked is negateBoolean. + */ + @Test + public void testSCANegateBoolean() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientSCAComponent"); + performTestNegateBoolean(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesService service using SCA binding. + * Service method invoked is negateBooleanArray. + */ + @Test + public void testSCANegateBooleanArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientSCAComponent"); + performTestNegateBooleanArray(primitivesServiceClient); + } + + /** + * Test the pass-by-value semantics of a remotable service with SCA binding. + * Test for boolean array. + */ + @Test + public void testSCAPassByValueBooleanArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientSCAComponent"); + Assert.assertTrue(primitivesServiceClient.passByValueBooleanArray()); + } + + /** + * Invokes the PrimitivesService service using SCA binding. + * Service method invoked is negateByte. + */ + @Test + public void testSCANegateByte() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientSCAComponent"); + performTestNegateByte(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesService service using SCA binding. + * Service method invoked is negateByteArray. + */ + @Test + public void testSCANegateByteArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientSCAComponent"); + performTestNegateByteArray(primitivesServiceClient); + } + + /** + * Test the pass-by-value semantics of a remotable service with SCA binding. + * Test for byte array. + */ + @Test + public void testSCAPassByValueByteArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientSCAComponent"); + Assert.assertTrue(primitivesServiceClient.passByValueByteArray()); + } + + /** + * Invokes the PrimitivesService service using SCA binding. + * Service method invoked is negateShort. + */ + @Test + public void testSCANegateShort() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientSCAComponent"); + performTestNegateShort(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesService service using SCA binding. + * Service method invoked is negateShortArray. + */ + @Test + public void testSCANegateShortArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientSCAComponent"); + performTestNegateShortArray(primitivesServiceClient); + } + + /** + * Test the pass-by-value semantics of a remotable service with SCA binding. + * Test for short array. + */ + @Test + public void testSCAPassByValueShortArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientSCAComponent"); + Assert.assertTrue(primitivesServiceClient.passByValueShortArray()); + } + + /** + * Invokes the PrimitivesService service using SCA binding. + * Service method invoked is negateInt. + */ + @Test + public void testSCANegateInt() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientSCAComponent"); + performTestNegateInt(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesService service using SCA binding. + * Service method invoked is negateIntArray. + */ + @Test + public void testSCANegateIntArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientSCAComponent"); + performTestNegateIntArray(primitivesServiceClient); + } + + /** + * Test the pass-by-value semantics of a remotable service with SCA binding. + * Test for int array. + */ + @Test + public void testSCAPassByValueIntArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientSCAComponent"); + Assert.assertTrue(primitivesServiceClient.passByValueIntArray()); + } + + /** + * Invokes the PrimitivesService service using SCA binding. + * Service method invoked is negateLong. + */ + @Test + public void testSCANegateLong() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientSCAComponent"); + performTestNegateLong(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesService service using SCA binding. + * Service method invoked is negateLongArray. + */ + @Test + public void testSCANegateLongArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientSCAComponent"); + performTestNegateLongArray(primitivesServiceClient); + } + + /** + * Test the pass-by-value semantics of a remotable service with SCA binding. + * Test for long array. + */ + @Test + public void testSCAPassByValueLongArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientSCAComponent"); + Assert.assertTrue(primitivesServiceClient.passByValueLongArray()); + } + + /** + * Invokes the PrimitivesService service using SCA binding. + * Service method invoked is negateFloat. + */ + @Test + public void testSCANegateFloat() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientSCAComponent"); + performTestNegateFloat(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesService service using SCA binding. + * Service method invoked is negateFloatArray. + */ + @Test + public void testSCANegateFloatArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientSCAComponent"); + performTestNegateFloatArray(primitivesServiceClient); + } + + /** + * Test the pass-by-value semantics of a remotable service with SCA binding. + * Test for float array. + */ + @Test + public void testSCAPassByValueFloatArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientSCAComponent"); + Assert.assertTrue(primitivesServiceClient.passByValueFloatArray()); + } + + /** + * Invokes the PrimitivesService service using SCA binding. + * Service method invoked is negateDouble. + */ + @Test + public void testSCANegateDouble() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientSCAComponent"); + performTestNegateDouble(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesService service using SCA binding. + * Service method invoked is negateDoubleArray. + */ + @Test + public void testSCANegateDoubleArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientSCAComponent"); + performTestNegateDoubleArray(primitivesServiceClient); + } + + /** + * Test the pass-by-value semantics of a remotable service with SCA binding. + * Test for double array. + */ + @Test + public void testSCAPassByValueDoubleArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientSCAComponent"); + Assert.assertTrue(primitivesServiceClient.passByValueDoubleArray()); + } + + /** + * Invokes the PrimitivesService service using WS binding. + * Service method invoked is negateBoolean. + */ + @Test + public void testWSNegateBoolean() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientWSComponent"); + performTestNegateBoolean(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesService service using WS binding. + * Service method invoked is negateBooleanArray. + */ + @Test + public void testWSNegateBooleanArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientWSComponent"); + performTestNegateBooleanArray(primitivesServiceClient); + } + + /** + * Test the pass-by-value semantics of a remotable service with WS binding. + * Test for boolean array. + */ + @Test + public void testWSPassByValueBooleanArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientWSComponent"); + Assert.assertTrue(primitivesServiceClient.passByValueBooleanArray()); + } + + /** + * Invokes the PrimitivesService service using WS binding. + * Service method invoked is negateByte. + */ + @Test + public void testWSNegateByte() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientWSComponent"); + performTestNegateByte(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesService service using WS binding. + * Service method invoked is negateByteArray. + */ + @Test + public void testWSNegateByteArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientWSComponent"); + performTestNegateByteArray(primitivesServiceClient); + } + + /** + * Test the pass-by-value semantics of a remotable service with WS binding. + * Test for byte array. + */ + @Test + public void testWSPassByValueByteArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientWSComponent"); + Assert.assertTrue(primitivesServiceClient.passByValueByteArray()); + } + + /** + * Invokes the PrimitivesService service using WS binding. + * Service method invoked is negateShort. + */ + @Test + public void testWSNegateShort() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientWSComponent"); + performTestNegateShort(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesService service using WS binding. + * Service method invoked is negateShortArray. + */ + @Test + public void testWSNegateShortArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientWSComponent"); + performTestNegateShortArray(primitivesServiceClient); + } + + /** + * Test the pass-by-value semantics of a remotable service with WS binding. + * Test for short array. + */ + @Test + public void testWSPassByValueShortArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientWSComponent"); + Assert.assertTrue(primitivesServiceClient.passByValueShortArray()); + } + + /** + * Invokes the PrimitivesService service using WS binding. + * Service method invoked is negateInt. + */ + @Test + public void testWSNegateInt() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientWSComponent"); + performTestNegateInt(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesService service using WS binding. + * Service method invoked is negateIntArray. + */ + @Test + public void testWSNegateIntArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientWSComponent"); + performTestNegateIntArray(primitivesServiceClient); + } + + /** + * Test the pass-by-value semantics of a remotable service with WS binding. + * Test for int array. + */ + @Test + public void testWSPassByValueIntArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientWSComponent"); + Assert.assertTrue(primitivesServiceClient.passByValueIntArray()); + } + + /** + * Invokes the PrimitivesService service using WS binding. + * Service method invoked is negateLong. + */ + @Test + public void testWSNegateLong() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientWSComponent"); + performTestNegateLong(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesService service using WS binding. + * Service method invoked is negateLongArray. + */ + @Test + public void testWSNegateLongArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientWSComponent"); + performTestNegateLongArray(primitivesServiceClient); + } + + /** + * Test the pass-by-value semantics of a remotable service with WS binding. + * Test for long array. + */ + @Test + public void testWSPassByValueLongArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientWSComponent"); + Assert.assertTrue(primitivesServiceClient.passByValueLongArray()); + } + + /** + * Invokes the PrimitivesService service using WS binding. + * Service method invoked is negateFloat. + */ + @Test + public void testWSNegateFloat() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientWSComponent"); + performTestNegateFloat(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesService service using WS binding. + * Service method invoked is negateFloatArray. + */ + @Test + public void testWSNegateFloatArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientWSComponent"); + performTestNegateFloatArray(primitivesServiceClient); + } + + /** + * Test the pass-by-value semantics of a remotable service with WS binding. + * Test for float array. + */ + @Test + public void testWSPassByValueFloatArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientWSComponent"); + Assert.assertTrue(primitivesServiceClient.passByValueFloatArray()); + } + + /** + * Invokes the PrimitivesService service using WS binding. + * Service method invoked is negateDouble. + */ + @Test + public void testWSNegateDouble() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientWSComponent"); + performTestNegateDouble(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesService service using WS binding. + * Service method invoked is negateDoubleArray. + */ + @Test + public void testWSNegateDoubleArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientWSComponent"); + performTestNegateDoubleArray(primitivesServiceClient); + } + + /** + * Test the pass-by-value semantics of a remotable service with WS binding. + * Test for double array. + */ + @Test + public void testWSPassByValueDoubleArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesServiceClientWSComponent"); + Assert.assertTrue(primitivesServiceClient.passByValueDoubleArray()); + } + + /** + * Invokes the PrimitivesLocalService service using SCA binding. + * Service method invoked is negateBoolean. + */ + @Test + public void testSCALocalNegateBoolean() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesLocalServiceClientSCAComponent"); + performTestNegateBoolean(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesLocalService service using SCA binding. + * Service method invoked is negateBooleanArray. + */ + @Test + public void testSCALocalNegateBooleanArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesLocalServiceClientSCAComponent"); + performTestNegateBooleanArray(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesLocalService service using SCA binding. + * Service method invoked is negateByte. + */ + @Test + public void testSCALocalNegateByte() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesLocalServiceClientSCAComponent"); + performTestNegateByte(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesLocalService service using SCA binding. + * Service method invoked is negateByteArray. + */ + @Test + public void testSCALocalNegateByteArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesLocalServiceClientSCAComponent"); + performTestNegateByteArray(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesLocalService service using SCA binding. + * Service method invoked is negateShort. + */ + @Test + public void testSCALocalNegateShort() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesLocalServiceClientSCAComponent"); + performTestNegateShort(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesLocalService service using SCA binding. + * Service method invoked is negateShortArray. + */ + @Test + public void testSCALocalNegateShortArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesLocalServiceClientSCAComponent"); + performTestNegateShortArray(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesLocalService service using SCA binding. + * Service method invoked is negateInt. + */ + @Test + public void testSCALocalNegateInt() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesLocalServiceClientSCAComponent"); + performTestNegateInt(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesLocalService service using SCA binding. + * Service method invoked is negateIntArray. + */ + @Test + public void testSCALocalNegateIntArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesLocalServiceClientSCAComponent"); + performTestNegateIntArray(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesLocalService service using SCA binding. + * Service method invoked is negateLong. + */ + @Test + public void testSCALocalNegateLong() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesLocalServiceClientSCAComponent"); + performTestNegateLong(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesLocalService service using SCA binding. + * Service method invoked is negateLongArray. + */ + @Test + public void testSCALocalNegateLongArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesLocalServiceClientSCAComponent"); + performTestNegateLongArray(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesLocalService service using SCA binding. + * Service method invoked is negateFloat. + */ + @Test + public void testSCALocalNegateFloat() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesLocalServiceClientSCAComponent"); + performTestNegateFloat(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesService service using SCA binding. + * Service method invoked is negateFloatArray. + */ + @Test + public void testSCALocalNegateFloatArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesLocalServiceClientSCAComponent"); + performTestNegateFloatArray(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesLocalService service using SCA binding. + * Service method invoked is negateDouble. + */ + @Test + public void testSCALocalNegateDouble() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesLocalServiceClientSCAComponent"); + performTestNegateDouble(primitivesServiceClient); + } + + /** + * Invokes the PrimitivesLocalService service using SCA binding. + * Service method invoked is negateDoubleArray. + */ + @Test + public void testSCALocalNegateDoubleArray() throws Exception { + PrimitivesServiceClient primitivesServiceClient = domain.getService(PrimitivesServiceClient.class, "PrimitivesLocalServiceClientSCAComponent"); + performTestNegateDoubleArray(primitivesServiceClient); + } + + private void performTestNegateBoolean(PrimitivesServiceClient primitivesServiceClient) { + Assert.assertTrue(primitivesServiceClient.negateBooleanForward(false)); + Assert.assertFalse(primitivesServiceClient.negateBooleanForward(true)); + } + + private void performTestNegateBooleanArray(PrimitivesServiceClient primitivesServiceClient) { + boolean flags[] = new boolean[2]; + flags[0] = false; + flags[1] = true; + boolean[] respFlags = primitivesServiceClient.negateBooleanArrayForward(flags); + Assert.assertEquals(flags.length, respFlags.length); + for(int i = 0; i < flags.length; ++i) { + Assert.assertEquals(!flags[i], respFlags[i]); + } + } + + private void performTestNegateByte(PrimitivesServiceClient primitivesServiceClient) { + byte[] ba = new byte[3]; + ba[0] = -1; + ba[1] = 0; + ba[2] = 1; + + for(int i = 0; i < ba.length; ++i) { + Assert.assertEquals((byte)-ba[i], primitivesServiceClient.negateByteForward(ba[i])); + } + } + + private void performTestNegateByteArray(PrimitivesServiceClient primitivesServiceClient) { + byte[] ba = new byte[3]; + ba[0] = -1; + ba[1] = 0; + ba[2] = 1; + + byte[] r = primitivesServiceClient.negateByteArrayForward(ba); + Assert.assertEquals(ba.length, r.length); + for(int i = 0; i < ba.length; ++i) { + Assert.assertEquals((byte)-ba[i], r[i]); + } + } + + private void performTestNegateShort(PrimitivesServiceClient primitivesServiceClient) { + short[] s = new short[3]; + s[0] = -1; + s[1] = 0; + s[2] = 1; + + for(int i = 0; i < s.length; ++i) { + Assert.assertEquals((short)-s[i], primitivesServiceClient.negateShortForward(s[i])); + } + } + + private void performTestNegateShortArray(PrimitivesServiceClient primitivesServiceClient) { + short[] s = new short[3]; + s[0] = -1; + s[1] = 0; + s[2] = 1; + + short[] r = primitivesServiceClient.negateShortArrayForward(s); + Assert.assertEquals(s.length, r.length); + for(int i = 0; i < s.length; ++i) { + Assert.assertEquals((short)-s[i], r[i]); + } + } + + private void performTestNegateInt(PrimitivesServiceClient primitivesServiceClient) { + int[] ia = new int[3]; + ia[0] = -1; + ia[1] = 0; + ia[2] = 1; + + for(int i = 0; i < ia.length; ++i) { + Assert.assertEquals(-ia[i], primitivesServiceClient.negateIntForward(ia[i])); + } + } + + private void performTestNegateIntArray(PrimitivesServiceClient primitivesServiceClient) { + int[] ia = new int[3]; + ia[0] = -1; + ia[1] = 0; + ia[2] = 1; + + int[] r = primitivesServiceClient.negateIntArrayForward(ia); + Assert.assertEquals(ia.length, r.length); + for(int i = 0; i < ia.length; ++i) { + Assert.assertEquals(-ia[i], r[i]); + } + } + + private void performTestNegateLong(PrimitivesServiceClient primitivesServiceClient) { + long[] la = new long[3]; + la[0] = -1; + la[1] = 0; + la[2] = 1; + + for(int i = 0; i < la.length; ++i) { + Assert.assertEquals(-la[i], primitivesServiceClient.negateLongForward(la[i])); + } + } + + private void performTestNegateLongArray(PrimitivesServiceClient primitivesServiceClient) { + long[] la = new long[3]; + la[0] = -1; + la[1] = 0; + la[2] = 1; + + long[] r = primitivesServiceClient.negateLongArrayForward(la); + Assert.assertEquals(la.length, r.length); + for(int i = 0; i < la.length; ++i) { + Assert.assertEquals(-la[i], r[i]); + } + } + + private void performTestNegateFloat(PrimitivesServiceClient primitivesServiceClient) { + float[] fa = new float[3]; + fa[0] = -1; + fa[1] = 0; + fa[2] = 1; + + for(int i = 0; i < fa.length; ++i) { + Assert.assertEquals(-fa[i], primitivesServiceClient.negateFloatForward(fa[i])); + } + } + + private void performTestNegateFloatArray(PrimitivesServiceClient primitivesServiceClient) { + float[] ia = new float[3]; + ia[0] = -1; + ia[1] = 0; + ia[2] = 1; + + float[] r = primitivesServiceClient.negateFloatArrayForward(ia); + Assert.assertEquals(ia.length, r.length); + for(int i = 0; i < ia.length; ++i) { + Assert.assertEquals(-ia[i], r[i]); + } + } + + private void performTestNegateDouble(PrimitivesServiceClient primitivesServiceClient) { + double[] da = new double[3]; + da[0] = -1; + da[1] = 0; + da[2] = 1; + + for(int i = 0; i < da.length; ++i) { + Assert.assertEquals(-da[i], primitivesServiceClient.negateDoubleForward(da[i])); + } + } + + private void performTestNegateDoubleArray(PrimitivesServiceClient primitivesServiceClient) { + double[] da = new double[3]; + da[0] = -1; + da[1] = 0; + da[2] = 1; + + double[] r = primitivesServiceClient.negateDoubleArrayForward(da); + Assert.assertEquals(da.length, r.length); + for(int i = 0; i < da.length; ++i) { + Assert.assertEquals(-da[i], r[i]); + } + } +} diff --git a/sca-java-1.x/branches/sca-java-1.3.2/itest/databindings/jaxb-bottom-up/src/test/java/org/apache/tuscany/sca/itest/databindings/jaxb/StandardTypesDatabindingTestCase.java b/sca-java-1.x/branches/sca-java-1.3.2/itest/databindings/jaxb-bottom-up/src/test/java/org/apache/tuscany/sca/itest/databindings/jaxb/StandardTypesDatabindingTestCase.java new file mode 100644 index 0000000000..4977baa84c --- /dev/null +++ b/sca-java-1.x/branches/sca-java-1.3.2/itest/databindings/jaxb-bottom-up/src/test/java/org/apache/tuscany/sca/itest/databindings/jaxb/StandardTypesDatabindingTestCase.java @@ -0,0 +1,1438 @@ +/* + * 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.itest.databindings.jaxb; + +import java.awt.Image; +import java.awt.image.BufferedImage; +import java.awt.image.PixelGrabber; +import java.io.IOException; +import java.io.InputStream; +import java.io.StringReader; +import java.io.StringWriter; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.net.URI; +import java.util.Calendar; +import java.util.Date; +import java.util.GregorianCalendar; +import java.util.TimeZone; +import java.util.UUID; + +import javax.activation.DataHandler; +import javax.xml.datatype.DatatypeConfigurationException; +import javax.xml.datatype.DatatypeFactory; +import javax.xml.datatype.Duration; +import javax.xml.datatype.XMLGregorianCalendar; +import javax.xml.namespace.QName; +import javax.xml.transform.Result; +import javax.xml.transform.Source; +import javax.xml.transform.TransformerFactory; +import javax.xml.transform.dom.DOMSource; +import javax.xml.transform.sax.SAXSource; +import javax.xml.transform.stream.StreamResult; +import javax.xml.transform.stream.StreamSource; + +import junit.framework.Assert; + +import org.apache.axiom.attachments.ByteArrayDataSource; +import org.apache.tuscany.sca.databinding.xml.String2Node; +import org.apache.tuscany.sca.host.embedded.SCADomain; +import org.apache.tuscany.sca.itest.databindings.jaxb.impl.StandardTypesTransformer; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; +import org.xml.sax.InputSource; + +/** + * @version $Rev$ $Date$ + */ +public class StandardTypesDatabindingTestCase { + + private static SCADomain domain; + + /** + * Runs before each test method + */ + @BeforeClass + public static void setUp() throws Exception { + try { + domain = SCADomain.newInstance("standard-types-service.composite"); + } catch (Throwable e) { + e.printStackTrace(); + } + } + + /** + * Runs after each test method + */ + @AfterClass + public static void tearDown() { + domain.close(); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewBigInteger. + */ + @Test + public void testSCANewBigInteger() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewBigInteger(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewBigIntegerArray. + */ + @Test + public void testSCANewBigIntegerArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewBigIntegerArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewBigDecimal. + */ + @Test + public void testSCANewBigDecimal() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewBigDecimal(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewBigDecimalArray. + */ + @Test + public void testSCANewBigDecimalArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewBigDecimalArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewCalendar. + */ + @Test + public void testSCANewCalendar() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewCalendar(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewCalendarArray. + */ + @Test + public void testSCANewCalendarArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewCalendarArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewDate. + */ + @Test + public void testSCANewDate() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewDate(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewDateArray. + */ + @Test + public void testSCANewDateArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewDateArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewQName. + */ + @Test + public void testSCANewQName() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewQName(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewQNameArray. + */ + @Test + public void testSCANewQNameArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewQNameArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewURI. + */ + @Test + public void testSCANewURI() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewURI(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewURIArray. + */ + @Test + public void testSCANewURIArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewURIArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewXMLGregorianCalendar. + */ + @Test + public void testSCANewXMLGregorianCalendar() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewXMLGregorianCalendar(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewXMLGregorianCalendarArray. + */ + @Test + public void testSCANewXMLGregorianCalendarArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewXMLGregorianCalendarArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewDuration. + */ + @Test + public void testSCANewDuration() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewDuration(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewDurationArray. + */ + @Test + public void testSCANewDurationArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewDurationArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewObject. + */ + @Test + public void testSCANewObject() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewObject(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewObjectArray. + */ + @Test + public void testSCANewObjectArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewObjectArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewImage. + */ + @Test + public void testSCANewImage() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewImage(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewImageArray. + */ + @Test + public void testSCANewImageArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewImageArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewDataHandler. + */ + @Test + public void testSCANewDataHandler() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewDataHandler(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewDataHandlerArray. + */ + @Test + public void testSCANewDataHandlerArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewDataHandlerArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewSource. + */ + @Test + public void testSCANewSource() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewSource(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewSourceArray. + */ + @Test + @Ignore("TUSCANY-2387") + public void testSCANewSourceArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewSourceArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewUUID. + */ + @Test + public void testSCANewUUID() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewUUID(serviceClient); + } + + /** + * Invokes the StandardTypesService service using SCA binding. + * Service method invoked is getNewUUIDArray. + */ + @Test + public void testSCANewUUIDArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientSCAComponent"); + performTestNewUUIDArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewBigInteger. + */ + @Test + public void testWSNewBigInteger() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewBigInteger(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewBigIntegerArray. + */ + @Test + public void testWSNewBigIntegerArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewBigIntegerArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewBigDecimal. + */ + @Test + public void testWSNewBigDecimal() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewBigDecimal(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewBigDecimalArray. + */ + @Test + public void testWSNewBigDecimalArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewBigDecimalArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewCalendar. + */ + @Test + public void testWSNewCalendar() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewCalendar(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewCalendarArray. + */ + @Test + public void testWSNewCalendarArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewCalendarArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewDate. + */ + @Test + public void testWSNewDate() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewDate(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewDateArray. + */ + @Test + public void testWSNewDateArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewDateArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewQName. + */ + @Test + public void testWSNewQName() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewQName(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewQNameArray. + */ + @Test + public void testWSNewQNameArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewQNameArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewURI. + */ + @Test + public void testWSNewURI() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewURI(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewURIArray. + */ + @Test + public void testWSNewURIArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewURIArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewXMLGregorianCalendar. + */ + @Test + public void testWSNewXMLGregorianCalendar() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewXMLGregorianCalendar(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewXMLGregorianCalendarArray. + */ + @Test + public void testWSNewXMLGregorianCalendarArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewXMLGregorianCalendarArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewDuration. + */ + @Test + public void testWSNewDuration() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewDuration(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewDurationArray. + */ + @Test + public void testWSNewDurationArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewDurationArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewObject. + */ + @Test + public void testWSNewObject() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewObject(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewObjectArray. + */ + @Test + public void testWSNewObjectArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewObjectArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewImage. + */ + @Test + public void testWSNewImage() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewImage(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewImageArray. + */ + @Test + public void testWSNewImageArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewImageArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewDataHandler. + */ + @Test + public void testWSNewDataHandler() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewDataHandler(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewDataHandlerArray. + */ + @Test + public void testWSNewDataHandlerArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewDataHandlerArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewSource. + */ + @Test + @Ignore("junit.framework.ComparisonFailure: null expected:<... encoding=\"UTF-8\"?><[a>A</a]>> but was:<... encoding=\"UTF-8\"?><[return xmlns=\"http://jaxb.databindings.itest.sca.tuscany.apache.org/\">A</return]>>") + public void testWSNewSource() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewSource(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewSourceArray. + */ + @Test + @Ignore("TUSCANY-2386") + public void testWSNewSourceArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewSourceArray(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewUUID. + */ + @Test + public void testWSNewUUID() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewUUID(serviceClient); + } + + /** + * Invokes the StandardTypesService service using WS binding. + * Service method invoked is getNewUUIDArray. + */ + @Test + public void testWSNewUUIDArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesServiceClientWSComponent"); + performTestNewUUIDArray(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewBigInteger. + */ + @Test + public void testSCALocalNewBigInteger() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewBigInteger(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewBigIntegerArray. + */ + @Test + public void testSCALocalNewBigIntegerArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewBigIntegerArray(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewBigDecimal. + */ + @Test + public void testSCALocalNewBigDecimal() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewBigDecimal(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewBigDecimalArray. + */ + @Test + public void testSCALocalNewBigDecimalArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewBigDecimalArray(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewCalendar. + */ + @Test + public void testSCALocalNewCalendar() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewCalendar(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewCalendarArray. + */ + @Test + public void testSCALocalNewCalendarArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewCalendarArray(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewDate. + */ + @Test + public void testSCALocalNewDate() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewDate(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewDateArray. + */ + @Test + public void testSCALocalNewDateArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewDateArray(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewQName. + */ + @Test + public void testSCALocalNewQName() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewQName(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewQNameArray. + */ + @Test + public void testSCALocalNewQNameArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewQNameArray(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewURI. + */ + @Test + public void testSCALocalNewURI() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewURI(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewURIArray. + */ + @Test + public void testSCALocalNewURIArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewURIArray(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewXMLGregorianCalendar. + */ + @Test + public void testSCALocalNewXMLGregorianCalendar() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewXMLGregorianCalendar(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewXMLGregorianCalendarArray. + */ + @Test + public void testSCALocalNewXMLGregorianCalendarArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewXMLGregorianCalendarArray(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewDuration. + */ + @Test + public void testSCALocalNewDuration() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewDuration(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewDurationArray. + */ + @Test + public void testSCALocalNewDurationArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewDurationArray(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewObject. + */ + @Test + public void testSCALocalNewObject() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewObject(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewObjectArray. + */ + @Test + public void testSCALocalNewObjectArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewObjectArray(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewImage. + */ + @Test + public void testSCALocalNewImage() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewImage(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewImageArray. + */ + @Test + public void testSCALocalNewImageArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewImageArray(serviceClient); + } + + /** + * Invokes the StandardTypesLocalLocalService service using SCA binding. + * Service method invoked is getNewDataHandler. + */ + @Test + public void testSCALocalNewDataHandler() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewDataHandler(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewDataHandlerArray. + */ + @Test + public void testSCALocalNewDataHandlerArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewDataHandlerArray(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewSource. + */ + @Test + public void testSCALocalNewSource() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewSource(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewSourceArray. + */ + @Test + public void testSCALocalNewSourceArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewSourceArray(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewUUID. + */ + @Test + public void testSCALocalNewUUID() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewUUID(serviceClient); + } + + /** + * Invokes the StandardTypesLocalService service using SCA binding. + * Service method invoked is getNewUUIDArray. + */ + @Test + public void testSCALocalNewUUIDArray() throws Exception { + StandardTypesServiceClient serviceClient = + domain.getService(StandardTypesServiceClient.class, "StandardTypesLocalServiceClientSCAComponent"); + performTestNewUUIDArray(serviceClient); + } + + private void performTestNewBigInteger(StandardTypesServiceClient serviceClient) { + BigInteger bi = new BigInteger("1234567890123456789012345678901234"); + BigInteger expected = bi.negate(); + BigInteger actual = serviceClient.getNewBigIntegerForward(bi); + Assert.assertEquals(expected, actual); + } + + private void performTestNewBigIntegerArray(StandardTypesServiceClient serviceClient) { + BigInteger[] bia = new BigInteger[2]; + bia[0] = new BigInteger("1234567890123456789012345678901234"); + bia[1] = new BigInteger("-98765432109876543210987654321"); + BigInteger[] actual = serviceClient.getNewBigIntegerArrayForward(bia); + Assert.assertEquals(bia.length, actual.length); + for (int i = 0; i < bia.length; ++i) { + Assert.assertEquals(bia[i].negate(), actual[i]); + } + } + + private void performTestNewBigDecimal(StandardTypesServiceClient serviceClient) { + BigDecimal bd = new BigDecimal("12345678901234567890.12345678901234"); + BigDecimal expected = bd.negate(); + BigDecimal actual = serviceClient.getNewBigDecimalForward(bd); + Assert.assertEquals(expected, actual); + } + + private void performTestNewBigDecimalArray(StandardTypesServiceClient serviceClient) { + BigDecimal[] bda = new BigDecimal[2]; + bda[0] = new BigDecimal("1234567890123456.789012345678901234"); + bda[1] = new BigDecimal("-987654321098765.43210987654321"); + BigDecimal[] actual = serviceClient.getNewBigDecimalArrayForward(bda); + Assert.assertEquals(bda.length, actual.length); + for (int i = 0; i < bda.length; ++i) { + Assert.assertEquals(bda[i].negate(), actual[i]); + } + } + + private void performTestNewCalendar(StandardTypesServiceClient serviceClient) { + Calendar[] ca = new Calendar[3]; + String[] tz = {"GMT+05:30", "GMT+00:00", "GMT-05:00"}; + for (int i = 0; i < ca.length; ++i) { + ca[i] = Calendar.getInstance(TimeZone.getTimeZone(tz[i])); + ca[i].set(Calendar.DAY_OF_MONTH, i + 1); + } + for (int i = 0; i < ca.length; ++i) { + Calendar actual = serviceClient.getNewCalendarForward(ca[i]); + ca[i].add(Calendar.DAY_OF_MONTH, 5); + if (actual instanceof GregorianCalendar && ca[i] instanceof GregorianCalendar) { + // FIXME: Is this a problem? + // The instance returned by service method invoked over binding.ws seems to have a gregorianCutover + // different from the instance passed. Adjust the gregorianCutover as per the input instance. + ((GregorianCalendar)actual).setGregorianChange(((GregorianCalendar)ca[i]).getGregorianChange()); + } + Assert.assertEquals(ca[i], actual); + } + } + + private void performTestNewCalendarArray(StandardTypesServiceClient serviceClient) { + Calendar[] ca = new Calendar[3]; + String[] tz = {"GMT+05:30", "GMT+00:00", "GMT-05:00"}; + for (int i = 0; i < ca.length; ++i) { + ca[i] = Calendar.getInstance(TimeZone.getTimeZone(tz[i])); + ca[i].set(Calendar.DAY_OF_MONTH, i + 1); + } + Calendar[] actual = serviceClient.getNewCalendarArrayForward(ca); + Assert.assertEquals(ca.length, actual.length); + for (int i = 0; i < ca.length; ++i) { + ca[i].add(Calendar.DAY_OF_MONTH, 5); + if (actual[i] instanceof GregorianCalendar && ca[i] instanceof GregorianCalendar) { + // FIXME: Is this a problem? + // The instance returned by service method invoked over binding.ws seems to have a gregorianCutover + // different from the instance passed. Adjust the gregorianCutover as per the input instance. + ((GregorianCalendar)actual[i]).setGregorianChange(((GregorianCalendar)ca[i]).getGregorianChange()); + } + Assert.assertEquals(ca[i], actual[i]); + } + } + + private void performTestNewDate(StandardTypesServiceClient serviceClient) { + Date d = new Date(); + Date expected = new Date(d.getTime() + 5 * 24 * 60 * 60 * 1000); + Date actual = serviceClient.getNewDateForward(d); + Assert.assertEquals(expected, actual); + } + + private void performTestNewDateArray(StandardTypesServiceClient serviceClient) { + Date[] d = new Date[2]; + Date[] expected = new Date[d.length]; + for (int i = 0; i < d.length; ++i) { + d[i] = new Date(); + d[i].setTime(d[i].getTime() + i * 24 * 60 * 60 * 1000); + expected[i] = new Date(d[i].getTime() + 5 * 24 * 60 * 60 * 1000); + } + Date[] actual = serviceClient.getNewDateArrayForward(d); + Assert.assertEquals(expected.length, actual.length); + for (int i = 0; i < expected.length; ++i) { + Assert.assertEquals(expected[i], actual[i]); + } + } + + private void performTestNewQName(StandardTypesServiceClient serviceClient) { + QName[] qnames = new QName[3]; + qnames[0] = new QName("localPart"); + qnames[1] = new QName("namespaceUri", "localPart"); + qnames[2] = new QName("namespaceUri", "localPart", "prefix"); + QName[] expected = new QName[qnames.length]; + for (int i = 0; i < qnames.length; ++i) { + expected[i] = + new QName(qnames[i].getNamespaceURI() + "q", qnames[i].getLocalPart() + "q", + qnames[i].getPrefix() + "q"); + } + for (int i = 0; i < qnames.length; ++i) { + QName actual = serviceClient.getNewQNameForward(qnames[i]); + Assert.assertEquals(expected[i], actual); + } + } + + private void performTestNewQNameArray(StandardTypesServiceClient serviceClient) { + QName[] qnames = new QName[4]; + qnames[0] = new QName("localPart"); + qnames[1] = new QName("namespaceUri", "localPart"); + qnames[2] = new QName("namespaceUri", "localPart", "prefix"); + qnames[3] = new QName("localPart2"); + QName[] expected = new QName[qnames.length]; + for (int i = 0; i < qnames.length; ++i) { + expected[i] = + new QName(qnames[i].getNamespaceURI() + "q", qnames[i].getLocalPart() + "q", + qnames[i].getPrefix() + "q"); + } + QName[] actual = serviceClient.getNewQNameArrayForward(qnames); + Assert.assertEquals(expected.length, actual.length); + for (int i = 0; i < qnames.length; ++i) { + Assert.assertEquals(expected[i], actual[i]); + } + } + + private void performTestNewURI(StandardTypesServiceClient serviceClient) { + URI[] uris = new URI[4]; + uris[0] = URI.create("a/b/c"); + uris[1] = URI.create("http://abc/"); + uris[2] = URI.create("ftp://a/b"); + uris[3] = URI.create("http://abc/").resolve("xyz"); + + for (int i = 0; i < uris.length; ++i) { + URI expected = uris[i].resolve("uri"); + URI actual = serviceClient.getNewURIForward(uris[i]); + Assert.assertEquals(expected, actual); + } + } + + private void performTestNewURIArray(StandardTypesServiceClient serviceClient) { + URI[] uris = new URI[4]; + uris[0] = URI.create("a/b/c"); + // [rfeng] We need to have a trialign / to avoid the resolving problem + // FIXME: [vamsi] This is actually a data transformation problem. The array being returned from the service method is + // not making to the caller intact. + uris[1] = URI.create("http://abc/"); + uris[2] = URI.create("ftp://a/b"); + uris[3] = URI.create("http://abc/").resolve("xyz"); + + URI[] expected = new URI[uris.length]; + for (int i = 0; i < uris.length; ++i) { + expected[i] = uris[i].resolve("uri"); + } + + URI[] actual = serviceClient.getNewURIArrayForward(uris); + Assert.assertEquals(expected.length, actual.length); + for (int i = 0; i < uris.length; ++i) { + Assert.assertEquals(expected[i], actual[i]); + } + } + + private void performTestNewXMLGregorianCalendar(StandardTypesServiceClient serviceClient) + throws DatatypeConfigurationException { + DatatypeFactory df = DatatypeFactory.newInstance(); + XMLGregorianCalendar[] xgcals = new XMLGregorianCalendar[3]; + xgcals[0] = df.newXMLGregorianCalendar(new GregorianCalendar(1974, GregorianCalendar.APRIL, 19)); + xgcals[1] = df.newXMLGregorianCalendar(new GregorianCalendar(1978, GregorianCalendar.OCTOBER, 13)); + xgcals[2] = df.newXMLGregorianCalendar(new GregorianCalendar(2006, GregorianCalendar.JUNE, 16)); + + for (int i = 0; i < xgcals.length; ++i) { + XMLGregorianCalendar actual = serviceClient.getNewXMLGregorianCalendarForward(xgcals[i]); + xgcals[i].setDay(xgcals[i].getDay() + 5); + Assert.assertEquals(xgcals[i], actual); + } + } + + private void performTestNewXMLGregorianCalendarArray(StandardTypesServiceClient serviceClient) + throws DatatypeConfigurationException { + DatatypeFactory df = DatatypeFactory.newInstance(); + XMLGregorianCalendar[] xgcals = new XMLGregorianCalendar[3]; + xgcals[0] = df.newXMLGregorianCalendar(new GregorianCalendar(1974, GregorianCalendar.APRIL, 19)); + xgcals[1] = df.newXMLGregorianCalendar(new GregorianCalendar(1978, GregorianCalendar.OCTOBER, 13)); + xgcals[2] = df.newXMLGregorianCalendar(new GregorianCalendar(2006, GregorianCalendar.JUNE, 16)); + + XMLGregorianCalendar[] actual = serviceClient.getNewXMLGregorianCalendarArrayForward(xgcals); + Assert.assertEquals(xgcals.length, actual.length); + for (int i = 0; i < xgcals.length; ++i) { + xgcals[i].setDay(xgcals[i].getDay() + 5); + Assert.assertEquals(xgcals[i], actual[i]); + } + } + + private void performTestNewDuration(StandardTypesServiceClient serviceClient) throws DatatypeConfigurationException { + DatatypeFactory df = DatatypeFactory.newInstance(); + Duration[] da = new Duration[3]; + da[0] = df.newDuration(1000000000000L); + da[1] = df.newDurationDayTime(1000000000000L); + da[2] = df.newDurationYearMonth(true, 1, 3); + + for (int i = 0; i < da.length; ++i) { + Assert.assertEquals(da[i].negate(), serviceClient.getNewDurationForward(da[i])); + } + } + + private void performTestNewObject(StandardTypesServiceClient serviceClient) { + Object[] objs = new Object[5]; + objs[0] = "Hello"; + objs[1] = 10; + objs[2] = null; + objs[3] = -1.0; + objs[4] = null; + + for (int i = 0; i < objs.length; ++i) { + Object expected = StandardTypesTransformer.getNewObject(objs[i]); + Object actual = serviceClient.getNewObjectForward(objs[i]); + Assert.assertEquals(expected, actual); + } + } + + private void performTestNewObjectArray(StandardTypesServiceClient serviceClient) { + Object[] objs = new Object[5]; + objs[0] = "Hello"; + objs[1] = 10; + objs[2] = null; + objs[3] = -1.0; + objs[4] = null; + + Object[] actual = serviceClient.getNewObjectArrayForward(objs); + Assert.assertEquals(objs.length, actual.length); + for (int i = 0; i < objs.length; ++i) { + Object expected = StandardTypesTransformer.getNewObject(objs[i]); + Assert.assertEquals(expected, actual[i]); + } + } + + private void performTestNewImage(StandardTypesServiceClient serviceClient) throws InterruptedException { + // Create some images to test with. + Image[] imgs = new Image[3]; + imgs[0] = new BufferedImage(10, 10, BufferedImage.TYPE_3BYTE_BGR); + imgs[1] = new BufferedImage(10, 10, BufferedImage.TYPE_INT_ARGB); + imgs[2] = new BufferedImage(10, 10, BufferedImage.TYPE_INT_RGB); + imgs[0].getGraphics().drawLine(1, 1, 8, 8); + imgs[1].getGraphics().drawLine(8, 1, 1, 8); + imgs[2].getGraphics().drawLine(1, 8, 8, 1); + + Image[] copy = imgs; + // Create the same images once again as the StandardTypesTransformer may manipulate the image passed. + imgs = new Image[3]; + imgs[0] = new BufferedImage(10, 10, BufferedImage.TYPE_3BYTE_BGR); + imgs[1] = new BufferedImage(10, 10, BufferedImage.TYPE_INT_ARGB); + imgs[2] = new BufferedImage(10, 10, BufferedImage.TYPE_INT_RGB); + imgs[0].getGraphics().drawLine(1, 1, 8, 8); + imgs[1].getGraphics().drawLine(8, 1, 1, 8); + imgs[2].getGraphics().drawLine(1, 8, 8, 1); + + // Make sure the images and copies are equal using ImageInfo + for(int i = 0; i < imgs.length; ++i) { + Assert.assertEquals(new ImageInfo(imgs[i]), new ImageInfo(copy[i])); + } + + for (int i = 0; i < imgs.length; ++i) { + Image actual = serviceClient.getNewImageForward(imgs[i]); + Image expected = StandardTypesTransformer.getNewImage(copy[i]); + // Compare using ImageInfo + Assert.assertEquals(new ImageInfo(expected), new ImageInfo(actual)); + } + } + + private void performTestNewImageArray(StandardTypesServiceClient serviceClient) throws InterruptedException { + // Create some images to test with. + Image[] imgs = new Image[3]; + imgs[0] = new BufferedImage(10, 10, BufferedImage.TYPE_3BYTE_BGR); + imgs[1] = new BufferedImage(10, 10, BufferedImage.TYPE_INT_ARGB); + imgs[2] = new BufferedImage(10, 10, BufferedImage.TYPE_INT_RGB); + imgs[0].getGraphics().drawLine(1, 1, 8, 8); + imgs[1].getGraphics().drawLine(8, 1, 1, 8); + imgs[2].getGraphics().drawLine(1, 8, 8, 1); + + Image[] copy = imgs; + // Create the same images once again as the StandardTypesTransformer may manipulate the image passed. + imgs = new Image[3]; + imgs[0] = new BufferedImage(10, 10, BufferedImage.TYPE_3BYTE_BGR); + imgs[1] = new BufferedImage(10, 10, BufferedImage.TYPE_INT_ARGB); + imgs[2] = new BufferedImage(10, 10, BufferedImage.TYPE_INT_RGB); + imgs[0].getGraphics().drawLine(1, 1, 8, 8); + imgs[1].getGraphics().drawLine(8, 1, 1, 8); + imgs[2].getGraphics().drawLine(1, 8, 8, 1); + + // Make sure the images and copies are equal using ImageInfo + for(int i = 0; i < imgs.length; ++i) { + Assert.assertEquals(new ImageInfo(imgs[i]), new ImageInfo(copy[i])); + } + + Image[] actual = serviceClient.getNewImageArrayForward(imgs); + Assert.assertEquals(imgs.length, actual.length); + for (int i = 0; i < imgs.length; ++i) { + Image expected = StandardTypesTransformer.getNewImage(copy[i]); + // Compare using ImageInfo + Assert.assertEquals(new ImageInfo(expected), new ImageInfo(actual[i])); + } + } + + private void performTestNewDurationArray(StandardTypesServiceClient serviceClient) + throws DatatypeConfigurationException { + DatatypeFactory df = DatatypeFactory.newInstance(); + Duration[] da = new Duration[3]; + da[0] = df.newDuration(1000000000000L); + da[1] = df.newDurationDayTime(1000000000000L); + da[2] = df.newDurationYearMonth(true, 1, 3); + + Duration[] actual = serviceClient.getNewDurationArrayForward(da); + Assert.assertEquals(da.length, actual.length); + for (int i = 0; i < da.length; ++i) { + Assert.assertEquals(da[i].negate(), actual[i]); + } + } + + private void performTestNewDataHandler(StandardTypesServiceClient serviceClient) throws IOException { + DataHandler[] dha = new DataHandler[3]; + dha[0] = new DataHandler("Some data", "text/plain"); + dha[1] = new DataHandler(this.getClass().getClassLoader().getResource("standard-types-service.composite")); + dha[2] = new DataHandler(new ByteArrayDataSource("Some data2".getBytes())); + + for (int i = 0; i < dha.length; ++i) { + DataHandler actual = serviceClient.getNewDataHandlerForward(dha[i]); + // Note: The DataHandler returned may use a different type of DataSource. + // Compare the data content instead of using equals(). + Assert.assertTrue(compare(dha[i], actual)); + } + } + + private void performTestNewDataHandlerArray(StandardTypesServiceClient serviceClient) throws IOException { + DataHandler[] dha = new DataHandler[3]; + dha[0] = new DataHandler("Some data", "text/plain"); + dha[1] = new DataHandler(this.getClass().getClassLoader().getResource("standard-types-service.composite")); + dha[2] = new DataHandler(new ByteArrayDataSource("Some data2".getBytes())); + + DataHandler[] actual = serviceClient.getNewDataHandlerArrayForward(dha); + Assert.assertEquals(dha.length, actual.length); + for (int i = 0; i < dha.length; ++i) { + // Note: The DataHandler returned may use a different type of DataSource. + // Compare the data content instead of using equals(). + Assert.assertTrue(compare(dha[i], actual[i])); + } + } + + private void performTestNewSource(StandardTypesServiceClient serviceClient) throws Exception { + String xml = new String("<a>A<b>B</b><c>C</c></a>"); + Source[] srcs = new Source[3]; + srcs[0] = new DOMSource(new String2Node().transform(xml, null)); + srcs[1] = new SAXSource(new InputSource(new StringReader(xml))); + srcs[2] = new StreamSource(new StringReader(xml)); + + for (int i = 0; i < srcs.length; ++i) { + Source expected = StandardTypesTransformer.getNewSource(srcs[i]); + Source actual = serviceClient.getNewSourceForward(srcs[i]); + // [rfeng] The data may come back as a different source + Assert.assertEquals(sourceToString(expected), sourceToString(actual)); + } + } + + private void performTestNewSourceArray(StandardTypesServiceClient serviceClient) throws Exception { + String xml = new String("<a>A<b>B</b><c>C</c></a>"); + Source[] srcs = new Source[3]; + srcs[0] = new DOMSource(new String2Node().transform(xml, null)); + srcs[1] = new SAXSource(new InputSource(new StringReader(xml))); + srcs[2] = new StreamSource(new StringReader(xml)); + + Source[] actual = serviceClient.getNewSourceArrayForward(srcs); + Source[] expected = new Source[srcs.length]; + for(int i = 0; i < srcs.length; ++i) { + expected[i] = StandardTypesTransformer.getNewSource(srcs[i]); + } + Assert.assertEquals(srcs.length, actual.length); + for (int i = 0; i < srcs.length; ++i) { + // [rfeng] The data may come back as a different source + Assert.assertEquals(sourceToString(expected[i]), sourceToString(actual[i])); + } + + } + + private void performTestNewUUID(StandardTypesServiceClient serviceClient) { + UUID[] uuids = new UUID[3]; + uuids[0] = UUID.nameUUIDFromBytes("ABCDEFGHJKLMNOPQRSTUVWXYZ".getBytes()); + uuids[1] = UUID.nameUUIDFromBytes("abcdefghjklmnopqrstuvwxyz".getBytes()); + uuids[2] = UUID.randomUUID(); + + for (int i = 0; i < uuids.length; ++i) { + UUID expected = UUID.fromString(uuids[i].toString() + "AAA"); + UUID actual = serviceClient.getNewUUIDForward(uuids[i]); + Assert.assertEquals(expected, actual); + } + } + + private void performTestNewUUIDArray(StandardTypesServiceClient serviceClient) { + UUID[] uuids = new UUID[3]; + uuids[0] = UUID.nameUUIDFromBytes("ABCDEFGHJKLMNOPQRSTUVWXYZ".getBytes()); + uuids[1] = UUID.nameUUIDFromBytes("abcdefghjklmnopqrstuvwxyz".getBytes()); + uuids[2] = UUID.randomUUID(); + + UUID[] actual = serviceClient.getNewUUIDArrayForward(uuids); + for (int i = 0; i < uuids.length; ++i) { + UUID expected = UUID.fromString(uuids[i].toString() + "AAA"); + Assert.assertEquals(expected, actual[i]); + } + } + + /** + * This method compares two DataHandlers. + * @return true if the data in the two handlers is the same. + */ + private boolean compare(DataHandler dh1, DataHandler dh2) throws IOException { + InputStream inp1 = dh1.getInputStream(); + InputStream inp2 = dh2.getInputStream(); + for(;;) { + int i1 = inp1.read(); + int i2 = inp2.read(); + if(i1 == -1 && i2 == -1) { + return true; + } else if(i1 != -1 && i2 != -1) { + if(i1 != i2) { + return false; + } + } else { + return false; + } + } + } + + /** + * This method returns the content of a source object as String. + */ + private String sourceToString(Source s) throws Exception { + StringWriter sw = new StringWriter(); + Result r = new StreamResult(sw); + TransformerFactory.newInstance().newTransformer().transform(s, r); + sw.close(); + return sw.toString(); + } + + /** + * This class initializes with the width, height and pixel data of a java.awt.Image object. + */ + private static class ImageInfo { + private int h, w, pixels[]; + public ImageInfo(Image img) throws InterruptedException { + w = img.getWidth(null); + h = img.getHeight(null); + pixels = new int[w*h]; + PixelGrabber pg = new PixelGrabber(img, 0, 0, w, h, pixels, 0, w); + pg.grabPixels(); + } + + public boolean equals(Object that) { + if(that == null) { + return false; + } else if(!(that instanceof ImageInfo)) { + return false; + } + + ImageInfo that1 = (ImageInfo)that; + if(w != that1.w || h != that1.h || pixels == null || that1.pixels == null || pixels.length != that1.pixels.length) { + return false; + } + for(int i = 0; i < pixels.length; ++i) { + if(pixels[i] != that1.pixels[i]) { + return false; + } + } + return true; + } + + public String toString() { + return this.getClass().getSimpleName()+"[w = "+w+", h = "+h+", pixels = "+pixels+"]"; + } + } +} |