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