bundles/org.simantics.databoard/testcases/org/simantics/databoard/tests/TestArrayUtils.java

   1 /*******************************************************************************
   2  *  Copyright (c) 2010 Association for Decentralized Information Management in
   3  *  Industry THTH ry.
   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
   8  *
   9  *  Contributors:
  10  *      VTT Technical Research Centre of Finland - initial API and implementation
  11  *******************************************************************************/
  12 package org.simantics.databoard.tests;
  13
  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;
  19
  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;
  28
  29 import org.junit.Before;
  30 import org.junit.Test;
  31 import org.simantics.databoard.util.ArrayUtils;
  32
  33 public class TestArrayUtils {
  34
  35         @Before
  36         public void setUp() {
  37         }
  38
  39         @Test
  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]);
  49         }
  50
  51         @Test
  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);
  57                 assertNotSame(b, c);
  58                 assertSame(b[0], c[0]);
  59                 assertSame(b[1], c[1]);
  60         }
  61
  62         @Test
  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);
  68                 assertNotSame(a, c);
  69                 assertSame(a[0], c[0]);
  70                 assertSame(a[1], c[1]);
  71         }
  72
  73         @Test
  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);
  79                 assertNotSame(a, c);
  80                 assertNotSame(b, c);
  81         }
  82
  83         @Test
  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]);
  91         }
  92
  93         @Test
  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]);
 101         }
 102
 103         @Test
 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]);
 111         }
 112
 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);
 119         }
 120
 121         @Test
 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);
 128         }
 129
 130         @Test
 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);
 137         }
 138
 139         @Test
 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);
 146         }
 147
 148         @Test
 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++)
 157                         assertNull(c[i]);
 158                 assertSame(a[0], c[0]);
 159                 assertSame(b[0], c[3]);
 160         }
 161
 162         @Test
 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]);
 172         }
 173
 174         @Test
 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]);
 183         }
 184
 185         @Test
 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);
 191         }
 192
 193         @Test
 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);
 199         }
 200
 201         @Test
 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);
 208                 assertNotSame(b, c);
 209         }
 210
 211         @Test
 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);
 218                 assertNotSame(a, c);
 219         }
 220
 221         @Test
 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]);
 229         }
 230
 231         @Test
 232         public void testAppendEmptyA() {
 233                 Integer[] a = new Integer[] { };
 234                 Integer b = 4;
 235                 Integer[] c = ArrayUtils.append(a, b, 5);
 236                 assertEquals(2, c.length);
 237                 assertSame(b, c[0]);
 238                 assertEquals(5, (int)c[1]);
 239         }
 240
 241         @Test
 242         public void testAppendEmptyB() {
 243                 Integer[] a = new Integer[] { 1, 2 };
 244                 Integer[] c = ArrayUtils.append(a);
 245                 assertArrayEquals(a, c);
 246                 assertNotSame(a, c);
 247                 assertSame(a[0], c[0]);
 248                 assertSame(a[1], c[1]);
 249         }
 250
 251         @Test
 252         public void testAppendEmptyBoth() {
 253                 Integer[] a = new Integer[] { };
 254                 Integer[] c = ArrayUtils.append(a);
 255                 assertEquals(0,  c.length);
 256                 assertNotSame(a, c);
 257         }
 258
 259         @Test
 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]);
 267         }
 268
 269         @Test
 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]);
 278         }
 279
 280         @Test
 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]);
 289         }
 290
 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]);
 297         }
 298
 299         @Test
 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]);
 312         }
 313
 314         @Test
 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]);
 324         }
 325
 326         @Test
 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]);
 335         }
 336
 337         @Test
 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]);
 347         }
 348
 349         @Test
 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]);
 358         }
 359
 360         @Test
 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]);
 370         }
 371
 372         @Test
 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++)
 381                         assertNull(c[i]);
 382                 assertSame(a[0], c[0]);
 383                 assertSame(b[0], c[3]);
 384         }
 385
 386         @Test
 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]);
 396         }
 397
 398         @Test
 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]);
 407         }
 408
 409         @Test
 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);
 415         }
 416
 417         @Test
 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);
 423         }
 424
 425         @Test
 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);
 432                 assertNotSame(b, c);
 433         }
 434
 435         @Test
 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);
 441                 assertNotSame(a, c);
 442         }
 443
 444         @Test
 445         public void testGetCommonBase1() {
 446                 Class<?> cl = ArrayUtils.getCommonBase(Integer.class, Double.class);
 447                 assertSame(Number.class, cl);
 448         }
 449
 450         @Test
 451         public void testGetCommonBase2() {
 452                 Class<?> cl = ArrayUtils.getCommonBase(Integer[].class, Double[].class);
 453                 assertSame(Number[].class, cl);
 454         }
 455
 456         @Test
 457         public void testGetCommonBase3() {
 458                 Class<?> cl = ArrayUtils.getCommonBase(Integer.class, Double[].class);
 459                 assertSame(Object.class, cl);
 460         }
 461
 462         @Test
 463         public void testGetCommonBase4() {
 464                 Class<?> cl = ArrayUtils.getCommonBase(List.class, ArrayList.class);
 465                 assertSame(List.class, cl);
 466         }
 467
 468         @Test
 469         public void testGetCommonBase5() {
 470                 Class<?> cl = ArrayUtils.getCommonBase(ArrayList.class, List.class);
 471                 assertSame(List.class, cl);
 472         }
 473
 474         @Test
 475         public void testGetCommonBase6() {
 476                 Class<?> cl = ArrayUtils.getCommonBase(ArrayList.class, LinkedList.class);
 477                 assertSame(AbstractList.class, cl);
 478         }
 479
 480         @Test
 481         public void testGetCommonBase7() {
 482                 Class<?> cl = ArrayUtils.getCommonBase(ArrayList.class, HashSet.class);
 483                 assertSame(AbstractCollection.class, cl);
 484         }
 485
 486         @Test
 487         public void testGetCommonBase8() {
 488                 Iterable<Object> foo = new Iterable<Object>() {
 489                         @Override
 490                         public Iterator<Object> iterator() {
 491                                 return null;
 492                         }
 493                 };
 494
 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());
 498
 499                 assertSame(Iterable.class, cl2);
 500                 assertSame(Iterable.class, cl3);
 501                 assertSame(Object.class, cl);
 502         }
 503 }