| /* $Id$ |
| * |
| * 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.etch.tests; |
| |
| import org.apache.etch.bindings.java.util.StrIntHashMap; |
| import org.apache.etch.tests.Test1.E1; |
| import org.apache.etch.tests.Test1.S1; |
| import org.apache.etch.tests.Test1.S2; |
| import org.apache.etch.tests.Test1.S3; |
| import org.apache.etch.tests.Test1.S4; |
| import org.junit.Before; |
| import org.junit.Test; |
| |
| |
| /** |
| * Simple tests to ensure that ImplTestClient and ImplTestServer are generated |
| * correctly |
| * |
| * @author gsandhir |
| */ |
| public class TestImplTest1 |
| { |
| private ImplTest1Server testServer = null; |
| private ImplTest1Client testClient = null; |
| |
| /** */ |
| @Before public void setup() { |
| RemoteTest1Client tc = null; |
| RemoteTest1Server ts = null; |
| testServer = new ImplTest1Server(tc); |
| testClient = new ImplTest1Client(ts); |
| } |
| |
| /** */ |
| @Test public void testIncr() { |
| |
| try |
| { |
| Integer i = new Integer(5); |
| testServer.incr(i); |
| testClient.incr( i ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testNothing() { |
| |
| try |
| { |
| testServer.nothing(); |
| testClient.nothing(); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testAdd() { |
| try |
| { |
| Integer i = new Integer(5); |
| Integer j = new Integer(3); |
| testServer.add( i,j); |
| testClient.add( i,j); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testSub() { |
| try |
| { |
| Integer i = new Integer(5); |
| Integer j = new Integer(3); |
| testServer.sub( i,j); |
| testClient.sub( i,j); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testSum() { |
| try |
| { |
| int[] x = {1,2,3}; |
| testServer.sum( x ); |
| testClient.sum( x ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testFill() { |
| try |
| { |
| Integer i = new Integer(5); |
| Integer j = new Integer(3); |
| testServer.fill( i, j ); |
| testClient.fill( i,j ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testFillObject() { |
| try |
| { |
| Integer i = new Integer(5); |
| Object j = null; |
| testServer.fillObject( i, j ); |
| testClient.fillObject( i,j ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| |
| /** */ |
| @Test public void testTrans() { |
| try |
| { |
| Integer i = new Integer(5); |
| E1 enumA = E1.A; |
| testServer.trans( enumA,i ); |
| testClient.trans( enumA,i ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testDist() { |
| try |
| { |
| S1 a = new S1(); |
| S1 b = new S1(); |
| testServer.dist( a, b ); |
| testClient.dist( a, b ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** @throws Exception */ |
| @Test public void testBlow() throws Exception { |
| try |
| { |
| Integer i = new Integer(5); |
| testServer.blow( "", i); |
| testClient.blow( "", i ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** @throws Exception */ |
| @Test public void testExcp5() throws Exception { |
| try |
| { |
| Integer i = new Integer(5); |
| Object value = null; |
| testServer.throwExcp5( "", i, value ); |
| testClient.throwExcp5( "", i, value ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** @throws Exception */ |
| @Test public void testExcp6() throws Exception { |
| try |
| { |
| Integer i = new Integer(5); |
| Object value[] = null; |
| testServer.throwExcp6( "", i, value ); |
| testClient.throwExcp6( "", i, value ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testBoolean() { |
| try |
| { |
| Boolean b = null; |
| testServer.p_boolean( b ); |
| testClient.p_boolean( b ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testBooleanArray() { |
| try |
| { |
| boolean b[] = null; |
| testServer.p_boolean_array( b ); |
| testClient.p_boolean_array( b ) ; |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testByte() { |
| try |
| { |
| Byte a = null; |
| testServer.p_byte( a ); |
| testClient.p_byte( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testByteArray() { |
| try |
| { |
| byte a[] = null; |
| testServer.p_byte_array( a ); |
| testClient.p_byte_array( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testShort() { |
| try |
| { |
| Short a = null; |
| testServer.p_short( a ); |
| testClient.p_short( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testShortArray() { |
| try |
| { |
| short a[] = null; |
| testServer.p_short_array( a ); |
| testClient.p_short_array( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testInt() { |
| try |
| { |
| Integer a = null; |
| testServer.p_int( a ); |
| testClient.p_int( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testIntArray() { |
| try |
| { |
| int a[] = null; |
| testServer.p_int_array( a ); |
| testClient.p_int_array( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testLong() { |
| try |
| { |
| Long a = null; |
| testServer.p_long( a ); |
| testClient.p_long( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testLongArray() { |
| try |
| { |
| long a[] = null; |
| testServer.p_long_array( a ); |
| testClient.p_long_array( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testFloat() { |
| try |
| { |
| Float a = null; |
| testServer.p_float( a ); |
| testClient.p_float( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testFloatArray() { |
| try |
| { |
| float a[] = null; |
| testServer.p_float_array( a ); |
| testClient.p_float_array( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| |
| |
| /** */ |
| @Test public void testDouble() { |
| try |
| { |
| Double a = null; |
| testServer.p_double( a ); |
| testClient.p_double( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testDoubleArray() { |
| try |
| { |
| double a[] = null; |
| testServer.p_double_array( a ); |
| testClient.p_double_array( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testString() { |
| try |
| { |
| String a = null; |
| testServer.p_string( a ); |
| testClient.p_string( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testStringArray() { |
| try |
| { |
| String a[] = null; |
| testServer.p_string_array( a ); |
| testClient.p_string_array( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testE1() { |
| try |
| { |
| E1 a = null; |
| testServer.p_E1( a ); |
| testClient.p_E1( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testE1Array() { |
| try |
| { |
| E1 a[] = null; |
| testServer.p_E1_array( a ); |
| testClient.p_E1_array( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testS1() { |
| try |
| { |
| S1 a = null; |
| testServer.p_S1( a ); |
| testClient.p_S1( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testS1Array() { |
| try |
| { |
| S1 a[] = null; |
| testServer.p_S1_array( a ); |
| testClient.p_S1_array( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testS2() { |
| try |
| { |
| S2 a = null; |
| testServer.p_S2( a ); |
| testClient.p_S2( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testS2Array() { |
| try |
| { |
| S2 a[] = null; |
| testServer.p_S2_array( a ); |
| testClient.p_S2_array( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testBlob() { |
| try |
| { |
| StrIntHashMap a = null; |
| testServer.p_Blob( a ); |
| testClient.p_Blob( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testBlobArray() { |
| try |
| { |
| StrIntHashMap[] a = null; |
| testServer.p_Blob_array( a ); |
| testClient.p_Blob_array( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testObject() { |
| try |
| { |
| Object a = null; |
| testServer.p_object( a ); |
| testClient.p_object( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testObjectArray() { |
| try |
| { |
| Object[] a = null; |
| testServer.p_object_array( a ); |
| testClient.p_object_array( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testObjectStruct() { |
| try |
| { |
| S3 a = null; |
| testServer.p_object_struct( a ); |
| testClient.p_object_struct( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testObjectStructArray() { |
| try |
| { |
| S4 a = null; |
| testServer.p_object_struct_array( a ); |
| testClient.p_object_struct_array( a ); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testAlwaysWork() { |
| try |
| { |
| |
| testServer.alwaysWorks(); |
| testClient.alwaysWorks(); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testAlwaysFail() { |
| try |
| { |
| |
| testServer.alwaysFails(); |
| testClient.alwaysFails(); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testIsTrue() { |
| try |
| { |
| |
| testServer.isTrue(); |
| testClient.isTrue(); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testIsFalse() { |
| try |
| { |
| |
| testServer.isFalse(); |
| testClient.isFalse(); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testM1() { |
| try |
| { |
| |
| testServer.m1(); |
| testClient.m1(); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testCanM1() { |
| try |
| { |
| |
| testServer.can_m1(); |
| testClient.can_m1(); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testM2() { |
| try |
| { |
| |
| testServer.m2(); |
| testClient.m2(); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testCanM2() { |
| try |
| { |
| Boolean b = null; |
| testServer.can_m2(b); |
| testClient.can_m2(b); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testM3() { |
| try |
| { |
| |
| testServer.m3(); |
| testClient.m3(); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testCanM3() { |
| try |
| { |
| Boolean b = null; |
| testServer.can_m3(b); |
| testClient.can_m3(b); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testM4() { |
| try |
| { |
| |
| testServer.m4(); |
| testClient.m4(); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testCanM4() { |
| try |
| { |
| Boolean b = null; |
| testServer.can_m4(b); |
| testClient.can_m4(b); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testM5() { |
| try |
| { |
| |
| testServer.m5(); |
| testClient.m5(); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testCanM5() { |
| try |
| { |
| Byte b = null; |
| testServer.can_m5(b); |
| testClient.can_m5(b); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testM6() { |
| try |
| { |
| |
| testServer.m6(); |
| testClient.m6(); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testCanM6() { |
| try |
| { |
| Short b = null; |
| testServer.can_m6(b); |
| testClient.can_m6(b); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testM7() { |
| try |
| { |
| |
| testServer.m7(); |
| testClient.m7(); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testCanM7() { |
| try |
| { |
| Integer b = null; |
| testServer.can_m7(b); |
| testClient.can_m7(b); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testM8() { |
| try |
| { |
| |
| testServer.m8(); |
| testClient.m8(); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testCanM8() { |
| try |
| { |
| Long b = null; |
| testServer.can_m8(b); |
| testClient.can_m8(b); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testM9() { |
| try |
| { |
| |
| testServer.m6(); |
| testClient.m6(); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testCanM9() { |
| try |
| { |
| Float b = null; |
| testServer.can_m9(b); |
| testClient.can_m9(b); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testM10() { |
| try |
| { |
| |
| testServer.m10(); |
| testClient.m10(); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testCanM10() { |
| try |
| { |
| Double b = null; |
| testServer.can_m10(b); |
| testClient.can_m10(b); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testM11() { |
| try |
| { |
| |
| testServer.m11(); |
| testClient.m11(); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testCanM11() { |
| try |
| { |
| String b = null; |
| testServer.can_m11(b); |
| testClient.can_m11(b); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testM12() { |
| try |
| { |
| |
| testServer.m12(); |
| testClient.m12(); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testCanM12() { |
| try |
| { |
| Integer b = null; |
| testServer.can_m12(b); |
| testClient.can_m12(b); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testM13() { |
| try |
| { |
| Integer b = null; |
| testServer.m13(b); |
| testClient.m13(b); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testCanM13() { |
| try |
| { |
| Integer b = null; |
| testServer.can_m13(b); |
| testClient.can_m13(b); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testM14() { |
| try |
| { |
| S1 b = null; |
| testServer.m14(b); |
| testClient.m14(b); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testCanM14() { |
| try |
| { |
| Integer b = null; |
| testServer.can_m14(b); |
| testClient.can_m14(b); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testM15() { |
| try |
| { |
| |
| testServer.m15(); |
| testClient.m15(); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| /** */ |
| @Test public void testCanM15() { |
| try |
| { |
| E1 b = null; |
| testServer.can_m15(b); |
| testClient.can_m15(b); |
| } |
| catch ( UnsupportedOperationException e ) |
| { |
| // ignore |
| |
| } |
| } |
| |
| |
| |
| |
| |
| } |
