1/* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 13 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 14 * License for the specific language governing permissions and limitations under 15 * the License. 16 */ 17 18package org.apache.harmony.tests.java.util; 19 20import java.io.Serializable; 21import java.util.Arrays; 22import java.util.ArrayList; 23import java.util.Comparator; 24import java.util.ConcurrentModificationException; 25import java.util.List; 26import java.util.RandomAccess; 27 28import junit.framework.TestCase; 29 30import org.apache.harmony.testframework.serialization.SerializationTest; 31 32public class Arrays2Test extends TestCase { 33 34 /** 35 * java.util.Arrays#binarySearch(double[], double) 36 */ 37 public void test_binarySearch$DD() { 38 double[] specials = new double[] { Double.NEGATIVE_INFINITY, 39 -Double.MAX_VALUE, -2d, -Double.MIN_VALUE, -0d, 0d, 40 Double.MIN_VALUE, 2d, Double.MAX_VALUE, 41 Double.POSITIVE_INFINITY, Double.NaN }; 42 43 for (int i = 0; i < specials.length; i++) { 44 int result = Arrays.binarySearch(specials, specials[i]); 45 assertTrue("Assert 0: " + specials[i] + " invalid: " + result, 46 result == i); 47 } 48 assertEquals("Assert 1: Invalid search index for -1d", 49 -4, Arrays.binarySearch(specials, -1d)); 50 assertEquals("Assert 2: Invalid search index for 1d", 51 -8, Arrays.binarySearch(specials, 1d)); 52 } 53 54 /** 55 * java.util.Arrays#binarySearch(float[], float) 56 */ 57 public void test_binarySearch$FF() { 58 float[] specials = new float[] { Float.NEGATIVE_INFINITY, 59 -Float.MAX_VALUE, -2f, -Float.MIN_VALUE, -0f, 0f, 60 Float.MIN_VALUE, 2f, Float.MAX_VALUE, Float.POSITIVE_INFINITY, 61 Float.NaN }; 62 63 for (int i = 0; i < specials.length; i++) { 64 int result = Arrays.binarySearch(specials, specials[i]); 65 assertTrue("Assert 0: " + specials[i] + " invalid: " + result, 66 result == i); 67 } 68 assertEquals("Assert 1: Invalid search index for -1f", 69 -4, Arrays.binarySearch(specials, -1f)); 70 assertEquals("Assert 2: Invalid search index for 1f", 71 -8, Arrays.binarySearch(specials, 1f)); 72 } 73 74 /** 75 * java.util.Arrays#equals(double[], double[]) 76 */ 77 public void test_equals$D$D() { 78 double d[] = new double[100]; 79 double x[] = new double[100]; 80 Arrays.fill(d, Double.MAX_VALUE); 81 Arrays.fill(x, Double.MIN_VALUE); 82 83 assertTrue("Assert 0: Inequal arrays returned true", !Arrays.equals(d, x)); 84 85 Arrays.fill(x, Double.MAX_VALUE); 86 assertTrue("Assert 1: equal arrays returned false", Arrays.equals(d, x)); 87 88 assertTrue("Assert 2: should be false", 89 !Arrays.equals(new double[] { 1.0 }, new double[] { 2.0 })); 90 91 assertTrue("Assert 3: NaN not equals", 92 Arrays.equals(new double[] { Double.NaN }, new double[] { Double.NaN })); 93 assertTrue("Assert 4: 0d equals -0d", 94 !Arrays.equals(new double[] { 0d }, new double[] { -0d })); 95 } 96 97 /** 98 * java.util.Arrays#equals(float[], float[]) 99 */ 100 public void test_equals$F$F() { 101 float d[] = new float[100]; 102 float x[] = new float[100]; 103 Arrays.fill(d, Float.MAX_VALUE); 104 Arrays.fill(x, Float.MIN_VALUE); 105 106 assertTrue("Assert 0: Inequal arrays returned true", !Arrays.equals(d, x)); 107 108 Arrays.fill(x, Float.MAX_VALUE); 109 assertTrue("Assert 1: equal arrays returned false", Arrays.equals(d, x)); 110 111 assertTrue("Assert 2: NaN not equals", 112 Arrays.equals(new float[] { Float.NaN }, new float[] { Float.NaN })); 113 assertTrue("Assert 3: 0f equals -0f", 114 !Arrays.equals(new float[] { 0f }, new float[] { -0f })); 115 } 116 117 /** 118 * java.util.Arrays#sort(double[]) 119 */ 120 public void test_sort$D() { 121 // Test a basic sort 122 double[] reversedArray = new double[100]; 123 for (int counter = 0; counter < reversedArray.length; counter++) { 124 reversedArray[counter] = (reversedArray.length - counter - 1); 125 } 126 Arrays.sort(reversedArray); 127 for (int counter = 0; counter < reversedArray.length; counter++) { 128 assertTrue("Assert 0: Resulting array not sorted", 129 reversedArray[counter] == counter); 130 } 131 132 // These have to sort as per the Double compare ordering 133 double[] specials1 = new double[] { Double.NaN, Double.MAX_VALUE, Double.MIN_VALUE, 0d, -0d, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY }; 134 double[] specials2 = new double[] { 0d, Double.POSITIVE_INFINITY, -0d, Double.NEGATIVE_INFINITY, Double.MIN_VALUE, Double.NaN, Double.MAX_VALUE }; 135 double[] answer = new double[] { Double.NEGATIVE_INFINITY, -0d, 0d, Double.MIN_VALUE, Double.MAX_VALUE, Double.POSITIVE_INFINITY, Double.NaN }; 136 137 Arrays.sort(specials1); 138 Object[] print1 = new Object[specials1.length]; 139 for (int i = 0; i < specials1.length; i++) { 140 print1[i] = new Double(specials1[i]); 141 } 142 assertTrue("Assert 1: specials sort incorrectly" + Arrays.asList(print1), 143 Arrays.equals(specials1, answer)); 144 145 Arrays.sort(specials2); 146 Object[] print2 = new Object[specials2.length]; 147 for (int i = 0; i < specials2.length; i++) { 148 print2[i] = new Double(specials2[i]); 149 } 150 assertTrue("Assert 2: specials sort incorrectly " + Arrays.asList(print2), 151 Arrays.equals(specials2, answer)); 152 } 153 154 /** 155 * java.util.Arrays#sort(float[]) 156 */ 157 public void test_sort$F() { 158 // Test a basic sort 159 float[] reversedArray = new float[100]; 160 for (int counter = 0; counter < reversedArray.length; counter++) { 161 reversedArray[counter] = (reversedArray.length - counter - 1); 162 } 163 Arrays.sort(reversedArray); 164 for (int counter = 0; counter < reversedArray.length; counter++) { 165 assertTrue("Assert 0: Resulting array not sorted", 166 reversedArray[counter] == counter); 167 } 168 169 float[] specials1 = new float[] { Float.NaN, Float.MAX_VALUE, Float.MIN_VALUE, 0f, -0f, Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY }; 170 float[] specials2 = new float[] { 0f, Float.POSITIVE_INFINITY, -0f, Float.NEGATIVE_INFINITY, Float.MIN_VALUE, Float.NaN, Float.MAX_VALUE }; 171 float[] answer = new float[] { Float.NEGATIVE_INFINITY, -0f, 0f, Float.MIN_VALUE, Float.MAX_VALUE, Float.POSITIVE_INFINITY, Float.NaN }; 172 173 Arrays.sort(specials1); 174 Object[] print1 = new Object[specials1.length]; 175 for (int i = 0; i < specials1.length; i++) { 176 print1[i] = new Float(specials1[i]); 177 } 178 assertTrue("Assert 1: specials sort incorrectly" + Arrays.asList(print1), 179 Arrays.equals(specials1, answer)); 180 181 Arrays.sort(specials2); 182 Object[] print2 = new Object[specials2.length]; 183 for (int i = 0; i < specials2.length; i++) { 184 print2[i] = new Float(specials2[i]); 185 } 186 assertTrue("Assert 2: specials sort incorrectly" + Arrays.asList(print2), 187 Arrays.equals(specials2, answer)); 188 } 189 190 /** 191 * java.util.Arrays#toString(boolean[]) 192 */ 193 public void test_toString$Z() { 194 assertEquals("null", Arrays.toString((boolean[]) null)); 195 assertEquals("[]", Arrays.toString(new boolean[] { })); 196 assertEquals("[true]", Arrays.toString(new boolean[] { true })); 197 assertEquals("[true, false]", Arrays.toString(new boolean[] { true, false })); 198 assertEquals("[true, false, true]", Arrays.toString(new boolean[] { true, false, true })); 199 } 200 201 /** 202 * java.util.Arrays#toString(byte[]) 203 */ 204 public void test_toString$B() { 205 assertEquals("null", Arrays.toString((byte[]) null)); 206 assertEquals("[]", Arrays.toString(new byte[] { })); 207 assertEquals("[0]", Arrays.toString(new byte[] { 0 })); 208 assertEquals("[-1, 0]", Arrays.toString(new byte[] { -1, 0 })); 209 assertEquals("[-1, 0, 1]", Arrays.toString(new byte[] { -1, 0, 1 })); 210 } 211 212 /** 213 * java.util.Arrays#toString(char[]) 214 */ 215 public void test_toString$C() { 216 assertEquals("null", Arrays.toString((char[]) null)); 217 assertEquals("[]", Arrays.toString(new char[] { })); 218 assertEquals("[a]", Arrays.toString(new char[] { 'a' })); 219 assertEquals("[a, b]", Arrays.toString(new char[] { 'a', 'b' })); 220 assertEquals("[a, b, c]", Arrays.toString(new char[] { 'a', 'b', 'c' })); 221 } 222 223 /** 224 * java.util.Arrays#toString(double[]) 225 */ 226 public void test_toString$D() { 227 assertEquals("null", Arrays.toString((double[]) null)); 228 assertEquals("[]", Arrays.toString(new double[] { })); 229 assertEquals("[0.0]", Arrays.toString(new double[] { 0.0D })); 230 assertEquals("[-1.0, 0.0]", Arrays.toString(new double[] { -1.0D, 0.0D })); 231 assertEquals("[-1.0, 0.0, 1.0]", Arrays.toString(new double[] { -1.0D, 0.0D, 1.0D })); 232 } 233 234 /** 235 * java.util.Arrays#toString(float[]) 236 */ 237 public void test_toString$F() { 238 assertEquals("null", Arrays.toString((float[]) null)); 239 assertEquals("[]", Arrays.toString(new float[] { })); 240 assertEquals("[0.0]", Arrays.toString(new float[] { 0.0F })); 241 assertEquals("[-1.0, 0.0]", Arrays.toString(new float[] { -1.0F, 0.0F })); 242 assertEquals("[-1.0, 0.0, 1.0]", Arrays.toString(new float[] { -1.0F, 0.0F, 1.0F })); 243 } 244 245 /** 246 * java.util.Arrays#toString(int[]) 247 */ 248 public void test_toString$I() { 249 assertEquals("null", Arrays.toString((int[]) null)); 250 assertEquals("[]", Arrays.toString(new int[] { })); 251 assertEquals("[0]", Arrays.toString(new int[] { 0 })); 252 assertEquals("[-1, 0]", Arrays.toString(new int[] { -1, 0 })); 253 assertEquals("[-1, 0, 1]", Arrays.toString(new int[] { -1, 0, 1 })); 254 } 255 256 /** 257 * java.util.Arrays#toString(long[]) 258 */ 259 public void test_toString$J() { 260 assertEquals("null", Arrays.toString((long[]) null)); 261 assertEquals("[]", Arrays.toString(new long[] { })); 262 assertEquals("[0]", Arrays.toString(new long[] { 0 })); 263 assertEquals("[-1, 0]", Arrays.toString(new long[] { -1, 0 })); 264 assertEquals("[-1, 0, 1]", Arrays.toString(new long[] { -1, 0, 1 })); 265 } 266 267 /** 268 * java.util.Arrays#toString(short[]) 269 */ 270 public void test_toString$S() { 271 assertEquals("null", Arrays.toString((short[]) null)); 272 assertEquals("[]", Arrays.toString(new short[] { })); 273 assertEquals("[0]", Arrays.toString(new short[] { 0 })); 274 assertEquals("[-1, 0]", Arrays.toString(new short[] { -1, 0 })); 275 assertEquals("[-1, 0, 1]", Arrays.toString(new short[] { -1, 0, 1 })); 276 } 277 278 /** 279 * java.util.Arrays#toString(Object[]) 280 */ 281 public void test_toString$Ljava_lang_Object() { 282 assertEquals("null", Arrays.toString((Object[]) null)); 283 assertEquals("[]", Arrays.toString(new Object[] { })); 284 assertEquals("[fixture]", Arrays.toString(new Object[] { "fixture" })); 285 assertEquals("[fixture, null]", Arrays.toString(new Object[] { "fixture", null })); 286 assertEquals("[fixture, null, fixture]", Arrays.toString(new Object[] { "fixture", null, "fixture" })); 287 } 288 289 /** 290 * java.util.Arrays#deepToString(Object[]) 291 */ 292 public void test_deepToString$java_lang_Object() { 293 assertEquals("null", Arrays.deepToString((Object[]) null)); 294 assertEquals("[]", Arrays.deepToString(new Object[] { })); 295 assertEquals("[fixture]", Arrays.deepToString(new Object[] { "fixture" })); 296 assertEquals("[fixture, null]", Arrays.deepToString(new Object[] { "fixture", null })); 297 assertEquals("[fixture, null, fixture]", Arrays.deepToString(new Object[] { "fixture", null, "fixture" })); 298 299 Object[] fixture = new Object[1]; 300 fixture[0] = fixture; 301 assertEquals("[[...]]", Arrays.deepToString(fixture)); 302 303 fixture = new Object[2]; 304 fixture[0] = "fixture"; 305 fixture[1] = fixture; 306 assertEquals("[fixture, [...]]", Arrays.deepToString(fixture)); 307 308 fixture = new Object[10]; 309 fixture[0] = new boolean[] { true, false }; 310 fixture[1] = new byte[] { 0, 1 }; 311 fixture[2] = new char[] { 'a', 'b' }; 312 fixture[3] = new double[] { 0.0D, 1.0D }; 313 fixture[4] = new float[] { 0.0F, 1.0F }; 314 fixture[5] = new int[] { 0, 1 }; 315 fixture[6] = new long[] { 0L, 1L }; 316 fixture[7] = new short[] { 0, 1 }; 317 fixture[8] = fixture[0]; 318 fixture[9] = new Object[9]; 319 ((Object[]) fixture[9])[0] = fixture; 320 ((Object[]) fixture[9])[1] = fixture[1]; 321 ((Object[]) fixture[9])[2] = fixture[2]; 322 ((Object[]) fixture[9])[3] = fixture[3]; 323 ((Object[]) fixture[9])[4] = fixture[4]; 324 ((Object[]) fixture[9])[5] = fixture[5]; 325 ((Object[]) fixture[9])[6] = fixture[6]; 326 ((Object[]) fixture[9])[7] = fixture[7]; 327 Object[] innerFixture = new Object[4]; 328 innerFixture[0] = "innerFixture0"; 329 innerFixture[1] = innerFixture; 330 innerFixture[2] = fixture; 331 innerFixture[3] = "innerFixture3"; 332 ((Object[]) fixture[9])[8] = innerFixture; 333 334 String expected = "[[true, false], [0, 1], [a, b], [0.0, 1.0], [0.0, 1.0], [0, 1], [0, 1], [0, 1], [true, false], [[...], [0, 1], [a, b], [0.0, 1.0], [0.0, 1.0], [0, 1], [0, 1], [0, 1], [innerFixture0, [...], [...], innerFixture3]]]"; 335 336 assertEquals(expected, Arrays.deepToString(fixture)); 337 } 338 339 public void test_asListTvararg() throws Exception { 340 List<String> stringsList = Arrays.asList("0", "1"); 341 assertEquals(2, stringsList.size()); 342 assertEquals("0", stringsList.get(0)); 343 assertEquals("1", stringsList.get(1)); 344 assertTrue(stringsList instanceof RandomAccess); 345 assertTrue(stringsList instanceof Serializable); 346 347 assertEquals(stringsList, SerializationTest 348 .copySerializable((Serializable) stringsList)); 349 350 //test from javadoc 351 List<String> stooges = Arrays.asList("Larry", "Moe", "Curly"); 352 assertEquals(3, stooges.size()); 353 assertEquals("Larry", stooges.get(0)); 354 assertEquals("Moe", stooges.get(1)); 355 assertEquals("Curly", stooges.get(2)); 356 357 stringsList = Arrays.asList((String) null); 358 assertEquals(1, stringsList.size()); 359 assertEquals((String) null, stringsList.get(0)); 360 361 try { 362 Arrays.asList((Object[]) null); 363 fail("No NPE"); 364 } catch (NullPointerException e) { 365 } 366 } 367 368 public void test_binarySearch$TTLjava_util_ComparatorsuperT() { 369 String[] strings = new String[] { "a", "B", "c", "D" }; 370 Arrays.sort(strings, String.CASE_INSENSITIVE_ORDER); 371 assertEquals(0, Arrays.binarySearch(strings, "a", 372 String.CASE_INSENSITIVE_ORDER)); 373 assertEquals(0, Arrays.binarySearch(strings, "A", 374 String.CASE_INSENSITIVE_ORDER)); 375 assertEquals(1, Arrays.binarySearch(strings, "b", 376 String.CASE_INSENSITIVE_ORDER)); 377 assertEquals(1, Arrays.binarySearch(strings, "B", 378 String.CASE_INSENSITIVE_ORDER)); 379 assertEquals(2, Arrays.binarySearch(strings, "c", 380 String.CASE_INSENSITIVE_ORDER)); 381 assertEquals(2, Arrays.binarySearch(strings, "C", 382 String.CASE_INSENSITIVE_ORDER)); 383 assertEquals(3, Arrays.binarySearch(strings, "d", 384 String.CASE_INSENSITIVE_ORDER)); 385 assertEquals(3, Arrays.binarySearch(strings, "D", 386 String.CASE_INSENSITIVE_ORDER)); 387 388 389 assertTrue(Arrays.binarySearch(strings, "e", 390 String.CASE_INSENSITIVE_ORDER) < 0); 391 assertTrue(Arrays.binarySearch(strings, "" + ('A' - 1), 392 String.CASE_INSENSITIVE_ORDER) < 0); 393 394 //test with null comparator, which switches back to Comparable 395 Arrays.sort(strings, null); 396 //B, D, a, c 397 assertEquals(2, Arrays.binarySearch(strings, "a", (Comparator<String>) null)); 398 assertEquals(-1, Arrays.binarySearch(strings, "A", (Comparator<String>) null)); 399 assertEquals(-4, Arrays.binarySearch(strings, "b", (Comparator<String>) null)); 400 assertEquals(0, Arrays.binarySearch(strings, "B", (Comparator<String>) null)); 401 assertEquals(3, Arrays.binarySearch(strings, "c", (Comparator<String>) null)); 402 assertEquals(-2, Arrays.binarySearch(strings, "C", (Comparator<String>) null)); 403 assertEquals(-5, Arrays.binarySearch(strings, "d", (Comparator<String>) null)); 404 assertEquals(1, Arrays.binarySearch(strings, "D", (Comparator<String>) null)); 405 406 assertTrue(Arrays.binarySearch(strings, "e", null) < 0); 407 assertTrue(Arrays.binarySearch(strings, "" + ('A' - 1), null) < 0); 408 409 try { 410 Arrays.binarySearch((String[]) null, "A", String.CASE_INSENSITIVE_ORDER); 411 fail("No NPE"); 412 } catch (NullPointerException e) { 413 } 414 415 try { 416 Arrays.binarySearch(strings, (String) null, String.CASE_INSENSITIVE_ORDER); 417 fail("No NPE"); 418 } catch (NullPointerException e) { 419 } 420 421 try { 422 Arrays.binarySearch(strings, (String) null, (Comparator<String>) null); 423 fail("No NPE"); 424 } catch (NullPointerException e) { 425 } 426 427 } 428 429 public void test_sort$TLjava_lang_ComparatorsuperT() { 430 String[] strings = new String[] { "a", "B", "c", "D" }; 431 Arrays.sort(strings, String.CASE_INSENSITIVE_ORDER); 432 assertEquals("a", strings[0]); 433 assertEquals("B", strings[1]); 434 assertEquals("c", strings[2]); 435 assertEquals("D", strings[3]); 436 437 //test with null comparator, which switches back to Comparable 438 Arrays.sort(strings, null); 439 //B, D, a, c 440 assertEquals("B", strings[0]); 441 assertEquals("D", strings[1]); 442 assertEquals("a", strings[2]); 443 assertEquals("c", strings[3]); 444 445 try { 446 Arrays.sort((String[]) null, String.CASE_INSENSITIVE_ORDER); 447 fail("No NPE"); 448 } catch (NullPointerException e) { 449 } 450 } 451 452 public void test_sort$TIILjava_lang_ComparatorsuperT() { 453 String[] strings = new String[] { "a", "B", "c", "D" }; 454 Arrays.sort(strings, 0, strings.length, String.CASE_INSENSITIVE_ORDER); 455 assertEquals("a", strings[0]); 456 assertEquals("B", strings[1]); 457 assertEquals("c", strings[2]); 458 assertEquals("D", strings[3]); 459 460 //test with null comparator, which switches back to Comparable 461 Arrays.sort(strings, 0, strings.length, null); 462 //B, D, a, c 463 assertEquals("B", strings[0]); 464 assertEquals("D", strings[1]); 465 assertEquals("a", strings[2]); 466 assertEquals("c", strings[3]); 467 468 try { 469 Arrays.sort((String[]) null, String.CASE_INSENSITIVE_ORDER); 470 fail("No NPE"); 471 } catch (NullPointerException e) { 472 } 473 } 474 475 public void test_forEach() throws Exception { 476 List<Integer> list = Arrays.asList(0, 1, 2); 477 ArrayList<Integer> output = new ArrayList<>(); 478 list.forEach(k -> output.add(k)); 479 assertEquals(list, output); 480 } 481 482 public void test_forEach_NPE() throws Exception { 483 List<Integer> list = Arrays.asList(0, 1, 2); 484 try { 485 list.forEach(null); 486 fail(); 487 } catch(NullPointerException expected) {} 488 } 489 490 public void test_replaceAll() throws Exception { 491 List<Integer> list = Arrays.asList(0, 1, 2); 492 list.replaceAll(k -> k + 1); 493 assertEquals((Integer)1, list.get(0)); 494 assertEquals((Integer)2, list.get(1)); 495 assertEquals((Integer)3, list.get(2)); 496 assertEquals(3, list.size()); 497 } 498 499 public void test_replaceAll_NPE() throws Exception { 500 List<Integer> list = Arrays.asList(0, 1, 2); 501 try { 502 list.replaceAll(null); 503 fail(); 504 } catch(NullPointerException expected) {} 505 } 506} 507