1/* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License 15 */ 16 17package libcore.java.util; 18 19import java.util.Arrays; 20import java.util.Random; 21 22public class ArraysTest extends junit.framework.TestCase { 23 24 /** 25 * java.util.Arrays#setAll(int[], java.util.function.IntUnaryOperator) 26 */ 27 public void test_setAll$I() { 28 int[] list = new int[3]; 29 list[0] = 0; 30 list[1] = 1; 31 list[2] = 2; 32 33 Arrays.setAll(list, x -> x + 1); 34 assertEquals(1, list[0]); 35 assertEquals(2, list[1]); 36 assertEquals(3, list[2]); 37 38 try { 39 Arrays.setAll(list, null); 40 fail(); 41 } catch (NullPointerException expected) { 42 } 43 44 try { 45 Arrays.setAll((int[]) null, (x -> x + 1)); 46 fail(); 47 } catch (NullPointerException expected) { 48 } 49 } 50 51 /** 52 * java.util.Arrays#parallelSetAll(int[], java.util.function.IntUnaryOperator) 53 */ 54 public void test_parallelSetAll$I() { 55 int[] list = new int[3]; 56 list[0] = 0; 57 list[1] = 1; 58 list[2] = 2; 59 60 Arrays.parallelSetAll(list, x -> x + 1); 61 assertEquals(1, list[0]); 62 assertEquals(2, list[1]); 63 assertEquals(3, list[2]); 64 65 try { 66 Arrays.parallelSetAll(list, null); 67 fail(); 68 } catch (NullPointerException expected) { 69 } 70 71 try { 72 Arrays.parallelSetAll((int[]) null, (x -> x + 1)); 73 fail(); 74 } catch (NullPointerException expected) { 75 } 76 } 77 78 /** 79 * java.util.Arrays#setAll(long[], java.util.function.IntToLongFunction) 80 */ 81 public void test_setAll$L() { 82 long[] list = new long[3]; 83 list[0] = 0; 84 list[1] = 1; 85 list[2] = 2; 86 87 Arrays.setAll(list, x -> x + 1); 88 assertEquals(1, list[0]); 89 assertEquals(2, list[1]); 90 assertEquals(3, list[2]); 91 92 try { 93 Arrays.setAll(list, null); 94 fail(); 95 } catch (NullPointerException expected) { 96 } 97 98 try { 99 Arrays.setAll((long[]) null, (x -> x + 1)); 100 fail(); 101 } catch (NullPointerException expected) { 102 } 103 } 104 105 /** 106 * java.util.Arrays#parallelSetAll(long[], java.util.function.IntToLongFunction) 107 */ 108 public void test_parallelSetAll$L() { 109 long[] list = new long[3]; 110 list[0] = 0; 111 list[1] = 1; 112 list[2] = 2; 113 114 Arrays.parallelSetAll(list, x -> x + 1); 115 assertEquals(1, list[0]); 116 assertEquals(2, list[1]); 117 assertEquals(3, list[2]); 118 119 try { 120 Arrays.parallelSetAll(list, null); 121 fail(); 122 } catch (NullPointerException expected) { 123 } 124 125 try { 126 Arrays.parallelSetAll((long[]) null, (x -> x + 1)); 127 fail(); 128 } catch (NullPointerException expected) { 129 } 130 } 131 132 /** 133 * java.util.Arrays#setAll(double[], java.util.function.IntToDoubleFunction) 134 */ 135 public void test_setAll$D() { 136 double[] list = new double[3]; 137 list[0] = 0.0d; 138 list[1] = 1.0d; 139 list[2] = 2.0d; 140 141 Arrays.setAll(list, x -> x + 0.5); 142 assertEquals(0.5d, list[0]); 143 assertEquals(1.5d, list[1]); 144 assertEquals(2.5d, list[2]); 145 146 try { 147 Arrays.setAll(list, null); 148 fail(); 149 } catch (NullPointerException expected) { 150 } 151 152 try { 153 Arrays.setAll((double[]) null, x -> x + 0.5); 154 fail(); 155 } catch (NullPointerException expected) { 156 } 157 } 158 159 /** 160 * java.util.Arrays#parallelSetAll(double[], java.util.function.IntToDoubleFunction) 161 */ 162 public void test_parallelSetAll$D() { 163 double[] list = new double[3]; 164 list[0] = 0.0d; 165 list[1] = 1.0d; 166 list[2] = 2.0d; 167 168 Arrays.parallelSetAll(list, x -> x + 0.5); 169 assertEquals(0.5d, list[0]); 170 assertEquals(1.5d, list[1]); 171 assertEquals(2.5d, list[2]); 172 173 try { 174 Arrays.parallelSetAll(list, null); 175 fail(); 176 } catch (NullPointerException expected) { 177 } 178 179 try { 180 Arrays.parallelSetAll((double[]) null, x -> x + 0.5); 181 fail(); 182 } catch (NullPointerException expected) { 183 } 184 } 185 186 /** 187 * java.util.Array#setAll(T[], java.util.function.IntFunction<\? extends T>) 188 */ 189 public void test_setAll$T() { 190 String[] strings = new String[3]; 191 strings[0] = "a"; 192 strings[0] = "b"; 193 strings[0] = "c"; 194 195 Arrays.setAll(strings, x -> "a" + x); 196 assertEquals("a0", strings[0]); 197 assertEquals("a1", strings[1]); 198 assertEquals("a2", strings[2]); 199 200 try { 201 Arrays.setAll(strings, null); 202 fail(); 203 } catch (NullPointerException expected) { 204 } 205 206 try { 207 Arrays.setAll((String[]) null, x -> "a" + x); 208 fail(); 209 } catch (NullPointerException expected) { 210 } 211 } 212 213 /** 214 * java.util.Array#parallelSetAll(T[], java.util.function.IntFunction<\? extends T>) 215 */ 216 public void test_parallelSetAll$T() { 217 String[] strings = new String[3]; 218 strings[0] = "a"; 219 strings[0] = "b"; 220 strings[0] = "c"; 221 222 Arrays.parallelSetAll(strings, x -> "a" + x); 223 assertEquals("a0", strings[0]); 224 assertEquals("a1", strings[1]); 225 assertEquals("a2", strings[2]); 226 227 try { 228 Arrays.parallelSetAll(strings, null); 229 fail(); 230 } catch (NullPointerException expected) { 231 } 232 233 try { 234 Arrays.parallelSetAll((String[]) null, x -> "a" + x); 235 fail(); 236 } catch (NullPointerException expected) { 237 } 238 } 239 240 /** 241 * java.util.Array#parallelPrefix(int[], java.util.function.IntBinaryOperator) 242 */ 243 public void test_parallelPrefix$I() { 244 // Get an arbitrary array of ints. 245 Random rand = new Random(0); 246 int[] list = new int[1000]; 247 for(int i = 0; i < list.length; ++i) { 248 list[i] = rand.nextInt() % 1000; // Prevent overflow 249 } 250 251 int[] seqResult = list.clone(); 252 253 // Sequential solution 254 for(int i = 0; i < seqResult.length - 1; ++i) { 255 seqResult[i + 1] += seqResult[i]; 256 } 257 258 Arrays.parallelPrefix(list, (x, y) -> x + y); 259 assertTrue(Arrays.equals(seqResult, list)); 260 261 try { 262 Arrays.parallelPrefix(list, null); 263 fail(); 264 } catch (NullPointerException expected) { 265 } 266 267 try { 268 Arrays.parallelPrefix((int[]) null, (x, y) -> x + y); 269 fail(); 270 } catch (NullPointerException expected) { 271 } 272 } 273 274 /** 275 * java.util.Array#parallelPrefix(int[], int, int, java.util.function.IntBinaryOperator) 276 */ 277 public void test_parallelPrefix$III() { 278 // Get an arbitrary array of ints. 279 Random rand = new Random(0); 280 int[] list = new int[1000]; 281 for(int i = 0; i < list.length; ++i) { 282 list[i] = rand.nextInt() % 1000; // Prevent overflow 283 } 284 285 int begin = 100, end = 500; 286 int[] seqResult = list.clone(); 287 288 // Sequential solution 289 for(int i = begin; i < end - 1; ++i) { 290 seqResult[i + 1] += seqResult[i]; 291 } 292 293 Arrays.parallelPrefix(list, begin, end, (x, y) -> x + y); 294 assertTrue(Arrays.equals(seqResult, list)); 295 296 try { 297 Arrays.parallelPrefix(list, begin, end, null); 298 fail(); 299 } catch (NullPointerException expected) { 300 } 301 302 try { 303 Arrays.parallelPrefix((int[]) null, begin, end, (x, y) -> x + y); 304 fail(); 305 } catch (NullPointerException expected) { 306 } 307 308 try { 309 Arrays.parallelPrefix(list, end, begin, (x, y) -> x + y); 310 fail(); 311 } catch (IllegalArgumentException expected) { 312 } 313 } 314 315 /** 316 * java.util.Array#parallelPrefix(long[], java.util.function.LongBinaryOperator) 317 */ 318 public void test_parallelPrefix$L() { 319 // Get an arbitrary array of ints. 320 Random rand = new Random(0); 321 long[] list = new long[1000]; 322 for(int i = 0; i < list.length; ++i) { 323 list[i] = rand.nextLong() % 1000000; // Prevent overflow 324 } 325 326 long[] seqResult = list.clone(); 327 328 // Sequential solution 329 for(int i = 0; i < seqResult.length - 1; ++i) { 330 seqResult[i + 1] += seqResult[i]; 331 } 332 333 Arrays.parallelPrefix(list, (x, y) -> x + y); 334 assertTrue(Arrays.equals(seqResult, list)); 335 336 try { 337 Arrays.parallelPrefix(list, null); 338 fail(); 339 } catch (NullPointerException expected) { 340 } 341 342 try { 343 Arrays.parallelPrefix((long[]) null, (x, y) -> x + y); 344 fail(); 345 } catch (NullPointerException expected) { 346 } 347 } 348 349 /** 350 * java.util.Array#parallelPrefix(long[], int, int, java.util.function.LongBinaryOperator) 351 */ 352 public void test_parallelPrefix$LII() { 353 // Get an arbitrary array of ints. 354 Random rand = new Random(0); 355 long[] list = new long[1000]; 356 for(int i = 0; i < list.length; ++i) { 357 list[i] = rand.nextLong() % 1000000; // Prevent overflow 358 } 359 360 int begin = 100, end = 500; 361 long[] seqResult = list.clone(); 362 363 // Sequential solution 364 for(int i = begin; i < end - 1; ++i) { 365 seqResult[i + 1] += seqResult[i]; 366 } 367 368 Arrays.parallelPrefix(list, begin, end, (x, y) -> x + y); 369 assertTrue(Arrays.equals(seqResult, list)); 370 371 try { 372 Arrays.parallelPrefix(list, begin, end, null); 373 fail(); 374 } catch (NullPointerException expected) { 375 } 376 377 try { 378 Arrays.parallelPrefix((long[]) null, begin, end, (x, y) -> x + y); 379 fail(); 380 } catch (NullPointerException expected) { 381 } 382 383 try { 384 Arrays.parallelPrefix(list, end, begin, (x, y) -> x + y); 385 fail(); 386 } catch (IllegalArgumentException expected) { 387 } 388 } 389 390 /** 391 * java.util.Array#parallelPrefix(double[], java.util.function.DoubleBinaryOperator) 392 */ 393 public void test_parallelPrefix$D() { 394 // Get an arbitrary array of ints. 395 Random rand = new Random(0); 396 double[] list = new double[1000]; 397 for(int i = 0; i < list.length; ++i) { 398 list[i] = rand.nextDouble() * 1000; 399 } 400 401 double[] seqResult = list.clone(); 402 403 // Sequential solution 404 for(int i = 0; i < seqResult.length - 1; ++i) { 405 seqResult[i + 1] += seqResult[i]; 406 } 407 408 Arrays.parallelPrefix(list, (x, y) -> x + y); 409 410 // Parallel double arithmetic contains error, reduce to integer for comparison. 411 int[] listInInt = Arrays.stream(list).mapToInt(x -> (int) x).toArray(); 412 int[] seqResultInInt = Arrays.stream(seqResult).mapToInt(x -> (int) x).toArray(); 413 assertTrue(Arrays.equals(seqResultInInt, listInInt)); 414 415 try { 416 Arrays.parallelPrefix(list, null); 417 fail(); 418 } catch (NullPointerException expected) { 419 } 420 421 try { 422 Arrays.parallelPrefix((double[]) null, (x, y) -> x + y); 423 fail(); 424 } catch (NullPointerException expected) { 425 } 426 } 427 428 /** 429 * java.util.Array#parallelPrefix(double[], int, int, java.util.function.DoubleBinaryOperator) 430 */ 431 public void test_parallelPrefix$DII() { 432 // Get an arbitrary array of ints. 433 Random rand = new Random(0); 434 double[] list = new double[1000]; 435 for(int i = 0; i < list.length; ++i) { 436 list[i] = rand.nextDouble() * 1000; 437 } 438 439 int begin = 100, end = 500; 440 double[] seqResult = list.clone(); 441 442 // Sequential solution 443 for(int i = begin; i < end - 1; ++i) { 444 seqResult[i + 1] += seqResult[i]; 445 } 446 447 Arrays.parallelPrefix(list, begin, end, (x, y) -> x + y); 448 449 // Parallel double arithmetic contains error, reduce to integer for comparison. 450 int[] listInInt = Arrays.stream(list).mapToInt(x -> (int) x).toArray(); 451 int[] seqResultInInt = Arrays.stream(seqResult).mapToInt(x -> (int) x).toArray(); 452 assertTrue(Arrays.equals(seqResultInInt, listInInt)); 453 454 try { 455 Arrays.parallelPrefix(list, begin, end, null); 456 fail(); 457 } catch (NullPointerException expected) { 458 } 459 460 try { 461 Arrays.parallelPrefix((double[]) null, begin, end, (x, y) -> x + y); 462 fail(); 463 } catch (NullPointerException expected) { 464 } 465 466 try { 467 Arrays.parallelPrefix(list, end, begin, (x, y) -> x + y); 468 fail(); 469 } catch (IllegalArgumentException expected) { 470 } 471 } 472 473 /** 474 * java.util.Array#parallelPrefix(T[], java.util.function.BinaryOperator<T>) 475 */ 476 public void test_parallelPrefix$T() { 477 String[] strings = new String[3]; 478 strings[0] = "a"; 479 strings[1] = "b"; 480 strings[2] = "c"; 481 482 Arrays.parallelPrefix(strings, (x, y) -> x + y); 483 assertEquals("a", strings[0]); 484 assertEquals("ab", strings[1]); 485 assertEquals("abc", strings[2]); 486 487 try { 488 Arrays.parallelPrefix(strings, null); 489 fail(); 490 } catch (NullPointerException expected) { 491 } 492 493 try { 494 Arrays.parallelPrefix((String[]) null, (x, y) -> x + y); 495 fail(); 496 } catch (NullPointerException expected) { 497 } 498 } 499 500 /** 501 * java.util.Array#parallelPrefix(T[], int, int, java.util.function.BinaryOperator<T>) 502 */ 503 public void test_parallelPrefix$TII() { 504 String[] strings = new String[5]; 505 strings[0] = "a"; 506 strings[1] = "b"; 507 strings[2] = "c"; 508 strings[3] = "d"; 509 strings[4] = "e"; 510 int begin = 1, end = 4; 511 512 Arrays.parallelPrefix(strings, begin, end, (x, y) -> x + y); 513 assertEquals("a", strings[0]); 514 assertEquals("b", strings[1]); 515 assertEquals("bc", strings[2]); 516 assertEquals("bcd", strings[3]); 517 assertEquals("e", strings[4]); 518 519 try { 520 Arrays.parallelPrefix(strings, begin, end, null); 521 fail(); 522 } catch (NullPointerException expected) { 523 } 524 525 try { 526 Arrays.parallelPrefix((String[]) null, begin, end, (x, y) -> x + y); 527 fail(); 528 } catch (NullPointerException expected) { 529 } 530 531 try { 532 Arrays.parallelPrefix(strings, end, begin, (x, y) -> x + y); 533 fail(); 534 } catch (IllegalArgumentException expected) { 535 } 536 } 537} 538