1 /*******************************************************************************
2 * Copyright (c) 2010 Association for Decentralized Information Management in
4 * All rights reserved. This program and the accompanying materials
5 * are made available under the terms of the Eclipse Public License v1.0
6 * which accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
10 * VTT Technical Research Centre of Finland - initial API and implementation
11 *******************************************************************************/
12 package org.simantics.databoard.tests;
14 import static org.junit.Assert.assertArrayEquals;
15 import static org.junit.Assert.assertEquals;
16 import static org.junit.Assert.assertNotSame;
17 import static org.junit.Assert.assertNull;
18 import static org.junit.Assert.assertSame;
20 import java.io.Serializable;
21 import java.util.AbstractCollection;
22 import java.util.AbstractList;
23 import java.util.ArrayList;
24 import java.util.HashSet;
25 import java.util.Iterator;
26 import java.util.LinkedList;
27 import java.util.List;
29 import org.junit.Before;
30 import org.junit.Test;
31 import org.simantics.databoard.util.ArrayUtils;
33 public class TestArrayUtils {
40 public void testConcatenate1() {
41 Integer[] a = new Integer[] { 1, 2, 3 };
42 Integer[] b = new Integer[] { 4, 5 };
43 Integer[] c = ArrayUtils.concatenate(a, b);
44 assertEquals(5, c.length);
45 for (int i = 0; i < c.length; i++)
46 assertEquals(i+1, (int)c[i]);
47 assertSame(a[0], c[0]);
48 assertSame(b[0], c[3]);
52 public void testConcatenateEmptyA() {
53 Integer[] a = new Integer[] { };
54 Integer[] b = new Integer[] { 4, 5 };
55 Integer[] c = ArrayUtils.concatenate(a, b);
56 assertArrayEquals(b, c);
58 assertSame(b[0], c[0]);
59 assertSame(b[1], c[1]);
63 public void testConcatenateEmptyB() {
64 Integer[] a = new Integer[] { 1, 2 };
65 Integer[] b = new Integer[] { };
66 Integer[] c = ArrayUtils.concatenate(a, b);
67 assertArrayEquals(a, c);
69 assertSame(a[0], c[0]);
70 assertSame(a[1], c[1]);
74 public void testConcatenateEmptyBoth() {
75 Integer[] a = new Integer[] { };
76 Integer[] b = new Integer[] { };
77 Integer[] c = ArrayUtils.concatenate(a, b);
78 assertEquals(0, c.length);
84 public void testConcatenateMixedTypes() {
85 Integer[] a = new Integer[] { 1 };
86 Double[] b = new Double[] { 2.0 };
87 Number[] c = ArrayUtils.concatenate(a, b);
88 assertSame(Number[].class, c.getClass());
89 assertSame(a[0], c[0]);
90 assertSame(b[0], c[1]);
94 public void testConcatenateMixedTypes2() {
95 Integer[] a = new Integer[] { 1 };
96 Double[] b = new Double[] { 2.0 };
97 Object[] c = ArrayUtils.concatenate(a, b);
98 assertSame(c.getClass(), Number[].class);
99 assertSame(a[0], c[0]);
100 assertSame(b[0], c[1]);
104 public void testConcatenateMixedTypes3() {
105 Integer[] a = new Integer[] { 1 };
106 Double[] b = new Double[] { 2.0 };
107 Object[] c = ArrayUtils.concatenate(a, b, Object.class);
108 assertSame(c.getClass(), Object[].class);
109 assertSame(a[0], c[0]);
110 assertSame(b[0], c[1]);
113 @Test(expected = ClassCastException.class)
114 public void testConcatenateMixedTypes4() {
115 Integer[] a = new Integer[] { 1 };
116 Double[] b = new Double[] { 2.0 };
117 @SuppressWarnings("unused")
118 Number[] c = (Number[])ArrayUtils.concatenate(a, b, Object.class);
122 public void testConcatenateMixedTypes5() {
123 Integer[] a = new Integer[] { 1 };
124 String[] b = new String[] { "foo" };
125 Object[] c = ArrayUtils.concatenate(a, b);
126 assertSame(Object[].class, c.getClass());
127 assertEquals(2, c.length);
131 public void testConcatenateMixedTypes6() {
132 Object[] a = new CharSequence[] { "bar" };
133 Object[] b = new String[] { "foo" };
134 Object[] c = ArrayUtils.concatenate(a, b);
135 assertSame(CharSequence[].class, c.getClass());
136 assertEquals(2, c.length);
140 public void testConcatenateMixedTypes7() {
141 Object[] a = new String[] { "bar" };
142 Object[] b = new CharSequence[] { "foo" };
143 Object[] c = ArrayUtils.concatenate(a, b);
144 assertSame(CharSequence[].class, c.getClass());
145 assertEquals(2, c.length);
149 public void testConcatenateLengthGt() {
150 Integer[] a = new Integer[] { 1, 2, 3 };
151 Integer[] b = new Integer[] { 4, 5 };
152 Integer[] c = ArrayUtils.concatenate(a, b, 8);
153 assertEquals(8, c.length);
154 for (int i = 0; i < 5; i++)
155 assertEquals(i+1, (int)c[i]);
156 for (int i = 5; i < 8; i++)
158 assertSame(a[0], c[0]);
159 assertSame(b[0], c[3]);
163 public void testConcatenateLengthLtB() {
164 Integer[] a = new Integer[] { 1, 2, 3 };
165 Integer[] b = new Integer[] { 4, 5 };
166 Integer[] c = ArrayUtils.concatenate(a, b, 4);
167 assertEquals(4, c.length);
168 for (int i = 0; i < 4; i++)
169 assertEquals(i+1, (int)c[i]);
170 assertSame(a[0], c[0]);
171 assertSame(b[0], c[3]);
175 public void testConcatenateLengthLtA() {
176 Integer[] a = new Integer[] { 1, 2, 3 };
177 Integer[] b = new Integer[] { 4, 5 };
178 Integer[] c = ArrayUtils.concatenate(a, b, 2);
179 assertEquals(2, c.length);
180 for (int i = 0; i < 2; i++)
181 assertEquals(i+1, (int)c[i]);
182 assertSame(a[0], c[0]);
186 public void testConcatenateLengthZero() {
187 Integer[] a = new Integer[] { 1, 2, 3 };
188 Integer[] b = new Integer[] { 4, 5 };
189 Integer[] c = ArrayUtils.concatenate(a, b, 0);
190 assertEquals(0, c.length);
194 public void testConcatenateLengthZeroEmptyA() {
195 Integer[] a = new Integer[] { };
196 Integer[] b = new Integer[] { 4, 5 };
197 Integer[] c = ArrayUtils.concatenate(a, b, 0);
198 assertEquals(0, c.length);
202 public void testConcatenateLengthEmptyA() {
203 Integer[] a = new Integer[] { };
204 Integer[] b = new Integer[] { 4, 5 };
205 Integer[] c = ArrayUtils.concatenate(a, b, 2);
206 assertEquals(2, c.length);
207 assertArrayEquals(b, c);
212 public void testConcatenateLengthEmptyB() {
213 Integer[] a = new Integer[] { 1, 2, 3 };
214 Integer[] b = new Integer[] { };
215 Integer[] c = ArrayUtils.concatenate(a, b, 3);
216 assertEquals(3, c.length);
217 assertArrayEquals(a, c);
222 public void testAppend1() {
223 Integer[] a = new Integer[] { 1, 2, 3 };
224 Integer[] c = ArrayUtils.append(a, 4, 5);
225 assertEquals(5, c.length);
226 for (int i = 0; i < c.length; i++)
227 assertEquals(i+1, (int)c[i]);
228 assertSame(a[0], c[0]);
232 public void testAppendEmptyA() {
233 Integer[] a = new Integer[] { };
235 Integer[] c = ArrayUtils.append(a, b, 5);
236 assertEquals(2, c.length);
238 assertEquals(5, (int)c[1]);
242 public void testAppendEmptyB() {
243 Integer[] a = new Integer[] { 1, 2 };
244 Integer[] c = ArrayUtils.append(a);
245 assertArrayEquals(a, c);
247 assertSame(a[0], c[0]);
248 assertSame(a[1], c[1]);
252 public void testAppendEmptyBoth() {
253 Integer[] a = new Integer[] { };
254 Integer[] c = ArrayUtils.append(a);
255 assertEquals(0, c.length);
260 public void testAppendMixedTypes() {
261 Integer[] a = new Integer[] { 1 };
262 Number[] c = ArrayUtils.append(a, 2.0);
263 assertEquals(2, c.length);
264 assertSame(Number[].class, c.getClass());
265 assertSame(a[0], c[0]);
266 assertEquals(2.0, c[1]);
270 public void testAppendMixedTypes2() {
271 Integer[] a = new Integer[] { 1 };
272 Double[] b = new Double[] { 2.0 };
273 Object[] c = ArrayUtils.append(a, b[0]);
274 assertEquals(2, c.length);
275 assertSame(Number[].class, c.getClass());
276 assertSame(a[0], c[0]);
277 assertSame(b[0], c[1]);
281 public void testAppendMixedTypes3() {
282 Integer[] a = new Integer[] { 1 };
283 Double[] b = new Double[] { 2.0 };
284 Object[] c = ArrayUtils.append(Comparable.class, a, b[0]);
285 assertEquals(2, c.length);
286 assertSame(c.getClass(), Comparable[].class);
287 assertSame(a[0], c[0]);
288 assertSame(b[0], c[1]);
291 @Test(expected = ClassCastException.class)
292 public void testAppendMixedTypes4() {
293 Integer[] a = new Integer[] { 1 };
294 Double[] b = new Double[] { 2.0 };
295 @SuppressWarnings("unused")
296 Number[] c = (Number[])ArrayUtils.append(Object.class, a, b[0]);
300 public void testAppendMixedTypes5() {
301 // Java generic type inference does some fairly unpredictable stuff here
302 Integer[] a = new Integer[] { 1 };
303 String[] b = new String[] { "foo" };
304 Object[] c = ArrayUtils.append(a, b[0]);
305 // c is in fact not an Object array!
306 // Java has determined that both Integer and String are instances of Comparable
307 // Could be a Comparable array just as well...
308 assert(Serializable[].class == c.getClass() || Comparable[].class == c.getClass());
309 assertEquals(2, c.length);
310 assertSame(a[0], c[0]);
311 assertSame(b[0], c[1]);
315 public void testAppendMixedTypes5b() {
316 Object[] a = new Integer[] { 1 };
317 Object[] b = new String[] { "foo" };
318 // b[0] is passed as a VarArg of type Object
319 Object[] c = ArrayUtils.append(a, b[0]);
320 assertSame(Object[].class, c.getClass());
321 assertEquals(2, c.length);
322 assertSame(a[0], c[0]);
323 assertSame(b[0], c[1]);
327 public void testAppendMixedTypes6() {
328 CharSequence[] a = new CharSequence[] { "bar" };
329 String[] b = new String[] { "foo" };
330 Object[] c = ArrayUtils.append(a, b[0]);
331 assertSame(CharSequence[].class, c.getClass());
332 assertEquals(2, c.length);
333 assertSame(a[0], c[0]);
334 assertSame(b[0], c[1]);
338 public void testAppendMixedTypes6b() {
339 Object[] a = new CharSequence[] { "bar" };
340 Object[] b = new String[] { "foo" };
341 // b[0] is passed as a VarArg of type Object
342 Object[] c = ArrayUtils.append(a, b[0]);
343 assertSame(Object[].class, c.getClass());
344 assertEquals(2, c.length);
345 assertSame(a[0], c[0]);
346 assertSame(b[0], c[1]);
350 public void testAppendMixedTypes7() {
351 String[] a = new String[] { "bar" };
352 CharSequence[] b = new CharSequence[] { "foo" };
353 Object[] c = ArrayUtils.append(a, b[0]);
354 assertSame(CharSequence[].class, c.getClass());
355 assertEquals(2, c.length);
356 assertSame(a[0], c[0]);
357 assertSame(b[0], c[1]);
361 public void testAppendMixedTypes7b() {
362 Object[] a = new String[] { "bar" };
363 Object[] b = new CharSequence[] { "foo" };
364 Object[] c = ArrayUtils.append(a, b[0]);
365 // Type inference presents b[0] as a VarArg of type Object
366 assertSame(Object[].class, c.getClass());
367 assertEquals(2, c.length);
368 assertSame(a[0], c[0]);
369 assertSame(b[0], c[1]);
373 public void testAppendLengthGt() {
374 Integer[] a = new Integer[] { 1, 2, 3 };
375 Integer[] b = new Integer[] { 4, 5 };
376 Integer[] c = ArrayUtils.append(8, a, b[0], b[1]);
377 assertEquals(8, c.length);
378 for (int i = 0; i < 5; i++)
379 assertEquals(i+1, (int)c[i]);
380 for (int i = 5; i < 8; i++)
382 assertSame(a[0], c[0]);
383 assertSame(b[0], c[3]);
387 public void testAppendLengthLtB() {
388 Integer[] a = new Integer[] { 1, 2, 3 };
389 Integer[] b = new Integer[] { 4, 5 };
390 Integer[] c = ArrayUtils.append(4, a, b[0], b[1]);
391 assertEquals(4, c.length);
392 for (int i = 0; i < 4; i++)
393 assertEquals(i+1, (int)c[i]);
394 assertSame(a[0], c[0]);
395 assertSame(b[0], c[3]);
399 public void testAppendLengthLtA() {
400 Integer[] a = new Integer[] { 1, 2, 3 };
401 Integer[] b = new Integer[] { 4, 5 };
402 Integer[] c = ArrayUtils.append(2, a, b[0], b[1]);
403 assertEquals(2, c.length);
404 for (int i = 0; i < 2; i++)
405 assertEquals(i+1, (int)c[i]);
406 assertSame(a[0], c[0]);
410 public void testAppendLengthZero() {
411 Integer[] a = new Integer[] { 1, 2, 3 };
412 Integer[] b = new Integer[] { 4, 5 };
413 Integer[] c = ArrayUtils.append(0, a, b[0], b[1]);
414 assertEquals(0, c.length);
418 public void testAppendLengthZeroEmptyA() {
419 Integer[] a = new Integer[] { };
420 Integer[] b = new Integer[] { 4, 5 };
421 Integer[] c = ArrayUtils.append(0, a, b[0], b[1]);
422 assertEquals(0, c.length);
426 public void testAppendLengthEmptyA() {
427 Integer[] a = new Integer[] { };
428 Integer[] b = new Integer[] { 4, 5 };
429 Integer[] c = ArrayUtils.append(2, a, b[0], b[1]);
430 assertEquals(2, c.length);
431 assertArrayEquals(b, c);
436 public void testAppendLengthEmptyB() {
437 Integer[] a = new Integer[] { 1, 2, 3 };
438 Integer[] c = ArrayUtils.append(3, a);
439 assertEquals(3, c.length);
440 assertArrayEquals(a, c);
445 public void testGetCommonBase1() {
446 Class<?> cl = ArrayUtils.getCommonBase(Integer.class, Double.class);
447 assertSame(Number.class, cl);
451 public void testGetCommonBase2() {
452 Class<?> cl = ArrayUtils.getCommonBase(Integer[].class, Double[].class);
453 assertSame(Number[].class, cl);
457 public void testGetCommonBase3() {
458 Class<?> cl = ArrayUtils.getCommonBase(Integer.class, Double[].class);
459 assertSame(Object.class, cl);
463 public void testGetCommonBase4() {
464 Class<?> cl = ArrayUtils.getCommonBase(List.class, ArrayList.class);
465 assertSame(List.class, cl);
469 public void testGetCommonBase5() {
470 Class<?> cl = ArrayUtils.getCommonBase(ArrayList.class, List.class);
471 assertSame(List.class, cl);
475 public void testGetCommonBase6() {
476 Class<?> cl = ArrayUtils.getCommonBase(ArrayList.class, LinkedList.class);
477 assertSame(AbstractList.class, cl);
481 public void testGetCommonBase7() {
482 Class<?> cl = ArrayUtils.getCommonBase(ArrayList.class, HashSet.class);
483 assertSame(AbstractCollection.class, cl);
487 public void testGetCommonBase8() {
488 Iterable<Object> foo = new Iterable<Object>() {
490 public Iterator<Object> iterator() {
495 Class<?> cl2 = ArrayUtils.getCommonBase(Iterable.class, foo.getClass());
496 Class<?> cl3 = ArrayUtils.getCommonBase(Iterable.class, ArrayList.class);
497 Class<?> cl = ArrayUtils.getCommonBase(ArrayList.class, foo.getClass());
499 assertSame(Iterable.class, cl2);
500 assertSame(Iterable.class, cl3);
501 assertSame(Object.class, cl);