1 // 2 // Copyright (c) ZeroC, Inc. All rights reserved. 3 // 4 5 package test.Ice.custom; 6 7 import java.io.PrintWriter; 8 import java.util.ArrayList; 9 import java.util.Arrays; 10 import java.util.HashMap; 11 import java.util.LinkedList; 12 import java.util.List; 13 import java.util.Map; 14 import java.nio.ByteBuffer; 15 import java.nio.ShortBuffer; 16 import java.nio.IntBuffer; 17 import java.nio.LongBuffer; 18 import java.nio.FloatBuffer; 19 import java.nio.DoubleBuffer; 20 21 import test.Ice.custom.Test.BoolSeqHolder; 22 import test.Ice.custom.Test.ByteSeqHolder; 23 import test.Ice.custom.Test.C; 24 import test.Ice.custom.Test.CArrayHolder; 25 import test.Ice.custom.Test.CListHolder; 26 import test.Ice.custom.Test.CSeqHolder; 27 import test.Ice.custom.Test.DSeqHolder; 28 import test.Ice.custom.Test.DoubleSeqHolder; 29 import test.Ice.custom.Test.E; 30 import test.Ice.custom.Test.ESeqHolder; 31 import test.Ice.custom.Test.FloatSeqHolder; 32 import test.Ice.custom.Test.IntSeqHolder; 33 import test.Ice.custom.Test.LongSeqHolder; 34 import test.Ice.custom.Test.S; 35 import test.Ice.custom.Test.SSeqHolder; 36 import test.Ice.custom.Test.ShortSeqHolder; 37 import test.Ice.custom.Test.StringSeqHolder; 38 import test.Ice.custom.Test.StringSeqSeqHolder; 39 import test.Ice.custom.Test.TestIntfPrx; 40 import test.Ice.custom.Test.TestIntfPrxHelper; 41 42 public class AllTests 43 { 44 private static void test(boolean b)45 test(boolean b) 46 { 47 if(!b) 48 { 49 throw new RuntimeException(); 50 } 51 } 52 53 public static TestIntfPrx allTests(test.TestHelper helper)54 allTests(test.TestHelper helper) 55 { 56 Ice.Communicator communicator = helper.communicator(); 57 PrintWriter out = helper.getWriter(); 58 out.print("testing stringToProxy... "); 59 out.flush(); 60 String ref = "test:" + helper.getTestEndpoint(0); 61 Ice.ObjectPrx obj = communicator.stringToProxy(ref); 62 test(obj != null); 63 out.println("ok"); 64 65 out.print("testing checked cast... "); 66 out.flush(); 67 TestIntfPrx t = TestIntfPrxHelper.checkedCast(obj); 68 test(t != null); 69 test(t.equals(obj)); 70 out.println("ok"); 71 72 out.print("testing custom sequences... "); 73 out.flush(); 74 75 { 76 // 77 // Create a sequence of C instances, where elements 1..n simply point to element 0. 78 // 79 C[] seq = new C[5]; 80 seq[0] = new C(); 81 for(int i = 1; i < seq.length; i++) 82 { 83 seq[i] = seq[0]; 84 } 85 86 // 87 // Invoke each operation and verify that the returned sequences have the same 88 // structure as the original. 89 // 90 CSeqHolder seqH = new CSeqHolder(); 91 C[] seqR = t.opCSeq(seq, seqH); 92 test(seqR.length == seq.length); 93 test(seqH.value.length == seq.length); 94 for(int i = 1; i < seq.length; i++) 95 { 96 test(seqR[i] != null); 97 test(seqR[i] == seqR[0]); 98 test(seqR[i] == seqH.value[i]); 99 } 100 101 ArrayList<C> arr = new ArrayList<C>(Arrays.asList(seq)); 102 CArrayHolder arrH = new CArrayHolder(); 103 List<C> arrR = t.opCArray(arr, arrH); 104 test(arrR.size() == arr.size()); 105 test(arrH.value.size() == arr.size()); 106 for(int i = 1; i < arr.size(); i++) 107 { 108 test(arrR.get(i) != null); 109 test(arrR.get(i) == arrR.get(0)); 110 test(arrR.get(i) == arrH.value.get(i)); 111 } 112 113 LinkedList<C> list = new LinkedList<C>(Arrays.asList(seq)); 114 CListHolder listH = new CListHolder(); 115 List<C> listR = t.opCList(list, listH); 116 test(listR.size() == list.size()); 117 test(listH.value.size() == list.size()); 118 for(int i = 1; i < list.size(); i++) 119 { 120 test(listR.get(i) != null); 121 test(listR.get(i) == listR.get(0)); 122 test(listR.get(i) == listH.value.get(i)); 123 } 124 } 125 126 { 127 final Boolean[] seq = { Boolean.TRUE, Boolean.FALSE, Boolean.TRUE, Boolean.FALSE, Boolean.TRUE }; 128 ArrayList<Boolean> list = new ArrayList<Boolean>(Arrays.asList(seq)); 129 BoolSeqHolder listH = new BoolSeqHolder(); 130 List<Boolean> listR = t.opBoolSeq(list, listH); 131 test(listH.value.equals(listR)); 132 test(listH.value.equals(list)); 133 } 134 135 { 136 final Byte[] seq = { Byte.valueOf((byte)0), Byte.valueOf((byte)1), Byte.valueOf((byte)2), 137 Byte.valueOf((byte)3) }; 138 ArrayList<Byte> list = new ArrayList<Byte>(Arrays.asList(seq)); 139 ByteSeqHolder listH = new ByteSeqHolder(); 140 List<Byte> listR = t.opByteSeq(list, listH); 141 test(listH.value.equals(listR)); 142 test(listH.value.equals(list)); 143 } 144 145 { 146 final Short[] seq = { Short.valueOf((short)0), Short.valueOf((short)1), Short.valueOf((short)2), 147 Short.valueOf((short)3) }; 148 ArrayList<Short> list = new ArrayList<Short>(Arrays.asList(seq)); 149 ShortSeqHolder listH = new ShortSeqHolder(); 150 List<Short> listR = t.opShortSeq(list, listH); 151 test(listH.value.equals(listR)); 152 test(listH.value.equals(list)); 153 } 154 155 { 156 final Integer[] seq = { Integer.valueOf(0), Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3) }; 157 ArrayList<Integer> list = new ArrayList<Integer>(Arrays.asList(seq)); 158 IntSeqHolder listH = new IntSeqHolder(); 159 List<Integer> listR = t.opIntSeq(list, listH); 160 test(listH.value.equals(listR)); 161 test(listH.value.equals(list)); 162 } 163 164 { 165 final Long[] seq = { Long.valueOf(0), Long.valueOf(1), Long.valueOf(2), Long.valueOf(3) }; 166 ArrayList<Long> list = new ArrayList<Long>(Arrays.asList(seq)); 167 LongSeqHolder listH = new LongSeqHolder(); 168 List<Long> listR = t.opLongSeq(list, listH); 169 test(listH.value.equals(listR)); 170 test(listH.value.equals(list)); 171 } 172 173 { 174 final Float[] seq = { Float.valueOf((float)0), Float.valueOf((float)1), Float.valueOf((float)2), 175 Float.valueOf((float)3) }; 176 ArrayList<Float> list = new ArrayList<Float>(Arrays.asList(seq)); 177 FloatSeqHolder listH = new FloatSeqHolder(); 178 List<Float> listR = t.opFloatSeq(list, listH); 179 test(listH.value.equals(listR)); 180 test(listH.value.equals(list)); 181 } 182 183 { 184 final Double[] seq = { Double.valueOf((double)0), Double.valueOf((double)1), Double.valueOf((double)2), 185 Double.valueOf((double)3) }; 186 ArrayList<Double> list = new ArrayList<Double>(Arrays.asList(seq)); 187 DoubleSeqHolder listH = new DoubleSeqHolder(); 188 List<Double> listR = t.opDoubleSeq(list, listH); 189 test(listH.value.equals(listR)); 190 test(listH.value.equals(list)); 191 } 192 193 { 194 final String[] seq = { "0", "1", "2", "3", "4" }; 195 ArrayList<String> list = new ArrayList<String>(Arrays.asList(seq)); 196 StringSeqHolder listH = new StringSeqHolder(); 197 List<String> listR = t.opStringSeq(list, listH); 198 test(listH.value.equals(listR)); 199 test(listH.value.equals(list)); 200 } 201 202 { 203 final E[] seq = { E.E1, E.E2, E.E3 }; 204 ArrayList<E> list = new ArrayList<E>(Arrays.asList(seq)); 205 ESeqHolder listH = new ESeqHolder(); 206 List<E> listR = t.opESeq(list, listH); 207 test(listH.value.equals(listR)); 208 test(listH.value.equals(list)); 209 } 210 211 { 212 S[] seq = new S[5]; 213 for(int i = 0; i < seq.length; i++) 214 { 215 seq[i] = new S(); 216 seq[i].en = E.values()[i % 3]; 217 } 218 ArrayList<S> list = new ArrayList<S>(Arrays.asList(seq)); 219 SSeqHolder listH = new SSeqHolder(); 220 List<S> listR = t.opSSeq(list, listH); 221 test(listH.value.equals(listR)); 222 test(listH.value.equals(list)); 223 } 224 225 { 226 ArrayList<Map<Integer, String>> list = new ArrayList<Map<Integer, String>>(); 227 for(int i = 0; i < 5; i++) 228 { 229 Map<Integer, String> m = new HashMap<Integer, String>(); 230 for(int j = 0; j < 4; j++) 231 { 232 m.put(j, "" + j); 233 } 234 list.add(m); 235 } 236 DSeqHolder listH = new DSeqHolder(); 237 List<Map<Integer, String>> listR = t.opDSeq(list, listH); 238 test(listH.value.equals(listR)); 239 test(listH.value.equals(list)); 240 } 241 242 { 243 List<List<String>> seq = new LinkedList<List<String>>(); 244 for(int i = 0; i < 5; i++) 245 { 246 final String[] arr = { "0", "1", "2", "3", "4" }; 247 seq.add(new ArrayList<String>(Arrays.asList(arr))); 248 } 249 StringSeqSeqHolder listH = new StringSeqSeqHolder(); 250 List<List<String>> listR = t.opStringSeqSeq(seq, listH); 251 test(listH.value.equals(listR)); 252 test(listH.value.equals(seq)); 253 } 254 255 { 256 final byte[] fullSeq = new byte[] {0, 1, 2, 3, 4, 5, 6, 7}; 257 final byte[] usedSeq = new byte[] {2, 3, 4, 5}; 258 259 ByteBuffer buffer = ByteBuffer.wrap(fullSeq, 2, 4); 260 Ice.Holder<ByteBuffer> bufferH = new Ice.Holder<ByteBuffer>(); 261 ByteBuffer bufferR = t.opByteBufferSeq(buffer, bufferH); 262 263 byte[] arr = new byte[bufferH.value.limit()]; 264 bufferH.value.get(arr, 0, bufferH.value.limit()); 265 test(Arrays.equals(arr, usedSeq)); 266 arr = new byte[bufferR.limit()]; 267 bufferR.get(arr, 0, bufferR.limit()); 268 test(Arrays.equals(arr, usedSeq)); 269 } 270 271 { 272 final short[] fullSeq = new short[] {0, 1, 2, 3, 4, 5, 6, 7}; 273 final short[] usedSeq = new short[] {2, 3, 4, 5}; 274 275 ShortBuffer buffer = ShortBuffer.wrap(fullSeq, 2, 4); 276 Ice.Holder<ShortBuffer> bufferH = new Ice.Holder<ShortBuffer>(); 277 ShortBuffer bufferR = t.opShortBufferSeq(buffer, bufferH); 278 279 short[] arr = new short[bufferH.value.limit()]; 280 bufferH.value.get(arr, 0, bufferH.value.limit()); 281 test(Arrays.equals(arr, usedSeq)); 282 arr = new short[bufferR.limit()]; 283 bufferR.get(arr, 0, bufferR.limit()); 284 test(Arrays.equals(arr, usedSeq)); 285 } 286 287 { 288 final int[] fullSeq = new int[] {0, 1, 2, 3, 4, 5, 6, 7}; 289 final int[] usedSeq = new int[] {2, 3, 4, 5}; 290 291 IntBuffer buffer = IntBuffer.wrap(fullSeq, 2, 4); 292 Ice.Holder<IntBuffer> bufferH = new Ice.Holder<IntBuffer>(); 293 IntBuffer bufferR = t.opIntBufferSeq(buffer, bufferH); 294 295 int[] arr = new int[bufferH.value.limit()]; 296 bufferH.value.get(arr, 0, bufferH.value.limit()); 297 test(Arrays.equals(arr, usedSeq)); 298 arr = new int[bufferR.limit()]; 299 bufferR.get(arr, 0, bufferR.limit()); 300 test(Arrays.equals(arr, usedSeq)); 301 } 302 303 { 304 final long[] fullSeq = new long[] {0L, 1L, 2L, 3L, 4L, 5L, 6L, 7L}; 305 final long[] usedSeq = new long[] {2L, 3L, 4L, 5L}; 306 307 LongBuffer buffer = LongBuffer.wrap(fullSeq, 2, 4); 308 Ice.Holder<LongBuffer> bufferH = new Ice.Holder<LongBuffer>(); 309 LongBuffer bufferR = t.opLongBufferSeq(buffer, bufferH); 310 311 long[] arr = new long[bufferH.value.limit()]; 312 bufferH.value.get(arr, 0, bufferH.value.limit()); 313 test(Arrays.equals(arr, usedSeq)); 314 arr = new long[bufferR.limit()]; 315 bufferR.get(arr, 0, bufferR.limit()); 316 test(Arrays.equals(arr, usedSeq)); 317 } 318 319 { 320 final float[] fullSeq = new float[] {0, 1, 2, 3, 4, 5, 6, 7}; 321 final float[] usedSeq = new float[] {2, 3, 4, 5}; 322 323 FloatBuffer buffer = FloatBuffer.wrap(fullSeq, 2, 4); 324 Ice.Holder<FloatBuffer> bufferH = new Ice.Holder<FloatBuffer>(); 325 FloatBuffer bufferR = t.opFloatBufferSeq(buffer, bufferH); 326 327 float[] arr = new float[bufferH.value.limit()]; 328 bufferH.value.get(arr, 0, bufferH.value.limit()); 329 test(Arrays.equals(arr, usedSeq)); 330 arr = new float[bufferR.limit()]; 331 bufferR.get(arr, 0, bufferR.limit()); 332 test(Arrays.equals(arr, usedSeq)); 333 } 334 335 { 336 final double[] fullSeq = new double[] {0, 1, 2, 3, 4, 5, 6, 7}; 337 final double[] usedSeq = new double[] {2, 3, 4, 5}; 338 339 DoubleBuffer buffer = DoubleBuffer.wrap(fullSeq, 2, 4); 340 Ice.Holder<DoubleBuffer> bufferH = new Ice.Holder<DoubleBuffer>(); 341 DoubleBuffer bufferR = t.opDoubleBufferSeq(buffer, bufferH); 342 343 double[] arr = new double[bufferH.value.limit()]; 344 bufferH.value.get(arr, 0, bufferH.value.limit()); 345 test(Arrays.equals(arr, usedSeq)); 346 arr = new double[bufferR.limit()]; 347 bufferR.get(arr, 0, bufferR.limit()); 348 test(Arrays.equals(arr, usedSeq)); 349 } 350 351 out.println("ok"); 352 353 return t; 354 } 355 } 356