1 /* 2 * Copyright (C) 2008 The Guava Authors 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 17 package com.google.common.primitives; 18 19 import static java.lang.Long.MAX_VALUE; 20 import static java.lang.Long.MIN_VALUE; 21 22 import com.google.common.annotations.GwtCompatible; 23 import com.google.common.annotations.GwtIncompatible; 24 import com.google.common.base.Converter; 25 import com.google.common.collect.testing.Helpers; 26 import com.google.common.testing.NullPointerTester; 27 import com.google.common.testing.SerializableTester; 28 import java.math.BigInteger; 29 import java.util.Arrays; 30 import java.util.Collection; 31 import java.util.Collections; 32 import java.util.Comparator; 33 import java.util.List; 34 import java.util.Random; 35 import junit.framework.TestCase; 36 37 /** 38 * Unit test for {@link Longs}. 39 * 40 * @author Kevin Bourrillion 41 */ 42 @GwtCompatible(emulated = true) 43 @SuppressWarnings("cast") // redundant casts are intentional and harmless 44 public class LongsTest extends TestCase { 45 private static final long[] EMPTY = {}; 46 private static final long[] ARRAY1 = {(long) 1}; 47 private static final long[] ARRAY234 = {(long) 2, (long) 3, (long) 4}; 48 49 private static final long[] VALUES = {MIN_VALUE, (long) -1, (long) 0, (long) 1, MAX_VALUE}; 50 51 @GwtIncompatible // Long.hashCode returns different values in GWT. testHashCode()52 public void testHashCode() { 53 for (long value : VALUES) { 54 assertEquals("hashCode for " + value, ((Long) value).hashCode(), Longs.hashCode(value)); 55 } 56 } 57 testCompare()58 public void testCompare() { 59 for (long x : VALUES) { 60 for (long y : VALUES) { 61 // note: spec requires only that the sign is the same 62 assertEquals(x + ", " + y, Long.valueOf(x).compareTo(y), Longs.compare(x, y)); 63 } 64 } 65 } 66 testContains()67 public void testContains() { 68 assertFalse(Longs.contains(EMPTY, (long) 1)); 69 assertFalse(Longs.contains(ARRAY1, (long) 2)); 70 assertFalse(Longs.contains(ARRAY234, (long) 1)); 71 assertTrue(Longs.contains(new long[] {(long) -1}, (long) -1)); 72 assertTrue(Longs.contains(ARRAY234, (long) 2)); 73 assertTrue(Longs.contains(ARRAY234, (long) 3)); 74 assertTrue(Longs.contains(ARRAY234, (long) 4)); 75 } 76 testIndexOf()77 public void testIndexOf() { 78 assertEquals(-1, Longs.indexOf(EMPTY, (long) 1)); 79 assertEquals(-1, Longs.indexOf(ARRAY1, (long) 2)); 80 assertEquals(-1, Longs.indexOf(ARRAY234, (long) 1)); 81 assertEquals(0, Longs.indexOf(new long[] {(long) -1}, (long) -1)); 82 assertEquals(0, Longs.indexOf(ARRAY234, (long) 2)); 83 assertEquals(1, Longs.indexOf(ARRAY234, (long) 3)); 84 assertEquals(2, Longs.indexOf(ARRAY234, (long) 4)); 85 assertEquals(1, Longs.indexOf(new long[] {(long) 2, (long) 3, (long) 2, (long) 3}, (long) 3)); 86 } 87 testIndexOf_arrayTarget()88 public void testIndexOf_arrayTarget() { 89 assertEquals(0, Longs.indexOf(EMPTY, EMPTY)); 90 assertEquals(0, Longs.indexOf(ARRAY234, EMPTY)); 91 assertEquals(-1, Longs.indexOf(EMPTY, ARRAY234)); 92 assertEquals(-1, Longs.indexOf(ARRAY234, ARRAY1)); 93 assertEquals(-1, Longs.indexOf(ARRAY1, ARRAY234)); 94 assertEquals(0, Longs.indexOf(ARRAY1, ARRAY1)); 95 assertEquals(0, Longs.indexOf(ARRAY234, ARRAY234)); 96 assertEquals(0, Longs.indexOf(ARRAY234, new long[] {(long) 2, (long) 3})); 97 assertEquals(1, Longs.indexOf(ARRAY234, new long[] {(long) 3, (long) 4})); 98 assertEquals(1, Longs.indexOf(ARRAY234, new long[] {(long) 3})); 99 assertEquals(2, Longs.indexOf(ARRAY234, new long[] {(long) 4})); 100 assertEquals( 101 1, 102 Longs.indexOf( 103 new long[] {(long) 2, (long) 3, (long) 3, (long) 3, (long) 3}, new long[] {(long) 3})); 104 assertEquals( 105 2, 106 Longs.indexOf( 107 new long[] {(long) 2, (long) 3, (long) 2, (long) 3, (long) 4, (long) 2, (long) 3}, 108 new long[] {(long) 2, (long) 3, (long) 4})); 109 assertEquals( 110 1, 111 Longs.indexOf( 112 new long[] {(long) 2, (long) 2, (long) 3, (long) 4, (long) 2, (long) 3, (long) 4}, 113 new long[] {(long) 2, (long) 3, (long) 4})); 114 assertEquals( 115 -1, 116 Longs.indexOf( 117 new long[] {(long) 4, (long) 3, (long) 2}, new long[] {(long) 2, (long) 3, (long) 4})); 118 } 119 testLastIndexOf()120 public void testLastIndexOf() { 121 assertEquals(-1, Longs.lastIndexOf(EMPTY, (long) 1)); 122 assertEquals(-1, Longs.lastIndexOf(ARRAY1, (long) 2)); 123 assertEquals(-1, Longs.lastIndexOf(ARRAY234, (long) 1)); 124 assertEquals(0, Longs.lastIndexOf(new long[] {(long) -1}, (long) -1)); 125 assertEquals(0, Longs.lastIndexOf(ARRAY234, (long) 2)); 126 assertEquals(1, Longs.lastIndexOf(ARRAY234, (long) 3)); 127 assertEquals(2, Longs.lastIndexOf(ARRAY234, (long) 4)); 128 assertEquals( 129 3, Longs.lastIndexOf(new long[] {(long) 2, (long) 3, (long) 2, (long) 3}, (long) 3)); 130 } 131 testMax_noArgs()132 public void testMax_noArgs() { 133 try { 134 Longs.max(); 135 fail(); 136 } catch (IllegalArgumentException expected) { 137 } 138 } 139 testMax()140 public void testMax() { 141 assertEquals(MIN_VALUE, Longs.max(MIN_VALUE)); 142 assertEquals(MAX_VALUE, Longs.max(MAX_VALUE)); 143 assertEquals( 144 (long) 9, Longs.max((long) 8, (long) 6, (long) 7, (long) 5, (long) 3, (long) 0, (long) 9)); 145 } 146 testMin_noArgs()147 public void testMin_noArgs() { 148 try { 149 Longs.min(); 150 fail(); 151 } catch (IllegalArgumentException expected) { 152 } 153 } 154 testMin()155 public void testMin() { 156 assertEquals(MIN_VALUE, Longs.min(MIN_VALUE)); 157 assertEquals(MAX_VALUE, Longs.min(MAX_VALUE)); 158 assertEquals( 159 (long) 0, Longs.min((long) 8, (long) 6, (long) 7, (long) 5, (long) 3, (long) 0, (long) 9)); 160 } 161 testConstrainToRange()162 public void testConstrainToRange() { 163 assertEquals((long) 1, Longs.constrainToRange((long) 1, (long) 0, (long) 5)); 164 assertEquals((long) 1, Longs.constrainToRange((long) 1, (long) 1, (long) 5)); 165 assertEquals((long) 3, Longs.constrainToRange((long) 1, (long) 3, (long) 5)); 166 assertEquals((long) -1, Longs.constrainToRange((long) 0, (long) -5, (long) -1)); 167 assertEquals((long) 2, Longs.constrainToRange((long) 5, (long) 2, (long) 2)); 168 try { 169 Longs.constrainToRange((long) 1, (long) 3, (long) 2); 170 fail(); 171 } catch (IllegalArgumentException expected) { 172 } 173 } 174 testConcat()175 public void testConcat() { 176 assertTrue(Arrays.equals(EMPTY, Longs.concat())); 177 assertTrue(Arrays.equals(EMPTY, Longs.concat(EMPTY))); 178 assertTrue(Arrays.equals(EMPTY, Longs.concat(EMPTY, EMPTY, EMPTY))); 179 assertTrue(Arrays.equals(ARRAY1, Longs.concat(ARRAY1))); 180 assertNotSame(ARRAY1, Longs.concat(ARRAY1)); 181 assertTrue(Arrays.equals(ARRAY1, Longs.concat(EMPTY, ARRAY1, EMPTY))); 182 assertTrue( 183 Arrays.equals( 184 new long[] {(long) 1, (long) 1, (long) 1}, Longs.concat(ARRAY1, ARRAY1, ARRAY1))); 185 assertTrue( 186 Arrays.equals( 187 new long[] {(long) 1, (long) 2, (long) 3, (long) 4}, Longs.concat(ARRAY1, ARRAY234))); 188 } 189 assertByteArrayEquals(byte[] expected, byte[] actual)190 private static void assertByteArrayEquals(byte[] expected, byte[] actual) { 191 assertTrue( 192 "Expected: " + Arrays.toString(expected) + ", but got: " + Arrays.toString(actual), 193 Arrays.equals(expected, actual)); 194 } 195 testToByteArray()196 public void testToByteArray() { 197 assertByteArrayEquals( 198 new byte[] {0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19}, 199 Longs.toByteArray(0x1213141516171819L)); 200 assertByteArrayEquals( 201 new byte[] { 202 (byte) 0xFF, (byte) 0xEE, (byte) 0xDD, (byte) 0xCC, 203 (byte) 0xBB, (byte) 0xAA, (byte) 0x99, (byte) 0x88 204 }, 205 Longs.toByteArray(0xFFEEDDCCBBAA9988L)); 206 } 207 testFromByteArray()208 public void testFromByteArray() { 209 assertEquals( 210 0x1213141516171819L, 211 Longs.fromByteArray(new byte[] {0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x33})); 212 assertEquals( 213 0xFFEEDDCCBBAA9988L, 214 Longs.fromByteArray( 215 new byte[] { 216 (byte) 0xFF, (byte) 0xEE, (byte) 0xDD, (byte) 0xCC, 217 (byte) 0xBB, (byte) 0xAA, (byte) 0x99, (byte) 0x88 218 })); 219 } 220 testFromByteArrayFails()221 public void testFromByteArrayFails() { 222 try { 223 Longs.fromByteArray(new byte[Longs.BYTES - 1]); 224 fail(); 225 } catch (IllegalArgumentException expected) { 226 } 227 } 228 testFromBytes()229 public void testFromBytes() { 230 assertEquals( 231 0x1213141516171819L, 232 Longs.fromBytes( 233 (byte) 0x12, 234 (byte) 0x13, 235 (byte) 0x14, 236 (byte) 0x15, 237 (byte) 0x16, 238 (byte) 0x17, 239 (byte) 0x18, 240 (byte) 0x19)); 241 assertEquals( 242 0xFFEEDDCCBBAA9988L, 243 Longs.fromBytes( 244 (byte) 0xFF, 245 (byte) 0xEE, 246 (byte) 0xDD, 247 (byte) 0xCC, 248 (byte) 0xBB, 249 (byte) 0xAA, 250 (byte) 0x99, 251 (byte) 0x88)); 252 } 253 testByteArrayRoundTrips()254 public void testByteArrayRoundTrips() { 255 Random r = new Random(5); 256 byte[] b = new byte[Longs.BYTES]; 257 258 for (int i = 0; i < 1000; i++) { 259 long num = r.nextLong(); 260 assertEquals(num, Longs.fromByteArray(Longs.toByteArray(num))); 261 262 r.nextBytes(b); 263 long value = Longs.fromByteArray(b); 264 assertTrue("" + value, Arrays.equals(b, Longs.toByteArray(value))); 265 } 266 } 267 testEnsureCapacity()268 public void testEnsureCapacity() { 269 assertSame(EMPTY, Longs.ensureCapacity(EMPTY, 0, 1)); 270 assertSame(ARRAY1, Longs.ensureCapacity(ARRAY1, 0, 1)); 271 assertSame(ARRAY1, Longs.ensureCapacity(ARRAY1, 1, 1)); 272 assertTrue( 273 Arrays.equals( 274 new long[] {(long) 1, (long) 0, (long) 0}, Longs.ensureCapacity(ARRAY1, 2, 1))); 275 } 276 testEnsureCapacity_fail()277 public void testEnsureCapacity_fail() { 278 try { 279 Longs.ensureCapacity(ARRAY1, -1, 1); 280 fail(); 281 } catch (IllegalArgumentException expected) { 282 } 283 try { 284 // notice that this should even fail when no growth was needed 285 Longs.ensureCapacity(ARRAY1, 1, -1); 286 fail(); 287 } catch (IllegalArgumentException expected) { 288 } 289 } 290 testJoin()291 public void testJoin() { 292 assertEquals("", Longs.join(",", EMPTY)); 293 assertEquals("1", Longs.join(",", ARRAY1)); 294 assertEquals("1,2", Longs.join(",", (long) 1, (long) 2)); 295 assertEquals("123", Longs.join("", (long) 1, (long) 2, (long) 3)); 296 } 297 testLexicographicalComparator()298 public void testLexicographicalComparator() { 299 List<long[]> ordered = 300 Arrays.asList( 301 new long[] {}, 302 new long[] {MIN_VALUE}, 303 new long[] {MIN_VALUE, MIN_VALUE}, 304 new long[] {MIN_VALUE, (long) 1}, 305 new long[] {(long) 1}, 306 new long[] {(long) 1, MIN_VALUE}, 307 new long[] {MAX_VALUE, MAX_VALUE - (long) 1}, 308 new long[] {MAX_VALUE, MAX_VALUE}, 309 new long[] {MAX_VALUE, MAX_VALUE, MAX_VALUE}); 310 311 Comparator<long[]> comparator = Longs.lexicographicalComparator(); 312 Helpers.testComparator(comparator, ordered); 313 } 314 315 @GwtIncompatible // SerializableTester testLexicographicalComparatorSerializable()316 public void testLexicographicalComparatorSerializable() { 317 Comparator<long[]> comparator = Longs.lexicographicalComparator(); 318 assertSame(comparator, SerializableTester.reserialize(comparator)); 319 } 320 testReverse()321 public void testReverse() { 322 testReverse(new long[] {}, new long[] {}); 323 testReverse(new long[] {1}, new long[] {1}); 324 testReverse(new long[] {1, 2}, new long[] {2, 1}); 325 testReverse(new long[] {3, 1, 1}, new long[] {1, 1, 3}); 326 testReverse(new long[] {-1, 1, -2, 2}, new long[] {2, -2, 1, -1}); 327 } 328 testReverse(long[] input, long[] expectedOutput)329 private static void testReverse(long[] input, long[] expectedOutput) { 330 input = Arrays.copyOf(input, input.length); 331 Longs.reverse(input); 332 assertTrue(Arrays.equals(expectedOutput, input)); 333 } 334 testReverse(long[] input, int fromIndex, int toIndex, long[] expectedOutput)335 private static void testReverse(long[] input, int fromIndex, int toIndex, long[] expectedOutput) { 336 input = Arrays.copyOf(input, input.length); 337 Longs.reverse(input, fromIndex, toIndex); 338 assertTrue(Arrays.equals(expectedOutput, input)); 339 } 340 testReverseIndexed()341 public void testReverseIndexed() { 342 testReverse(new long[] {}, 0, 0, new long[] {}); 343 testReverse(new long[] {1}, 0, 1, new long[] {1}); 344 testReverse(new long[] {1, 2}, 0, 2, new long[] {2, 1}); 345 testReverse(new long[] {3, 1, 1}, 0, 2, new long[] {1, 3, 1}); 346 testReverse(new long[] {3, 1, 1}, 0, 1, new long[] {3, 1, 1}); 347 testReverse(new long[] {-1, 1, -2, 2}, 1, 3, new long[] {-1, -2, 1, 2}); 348 } 349 testSortDescending()350 public void testSortDescending() { 351 testSortDescending(new long[] {}, new long[] {}); 352 testSortDescending(new long[] {1}, new long[] {1}); 353 testSortDescending(new long[] {1, 2}, new long[] {2, 1}); 354 testSortDescending(new long[] {1, 3, 1}, new long[] {3, 1, 1}); 355 testSortDescending(new long[] {-1, 1, -2, 2}, new long[] {2, 1, -1, -2}); 356 } 357 testSortDescending(long[] input, long[] expectedOutput)358 private static void testSortDescending(long[] input, long[] expectedOutput) { 359 input = Arrays.copyOf(input, input.length); 360 Longs.sortDescending(input); 361 assertTrue(Arrays.equals(expectedOutput, input)); 362 } 363 testSortDescending( long[] input, int fromIndex, int toIndex, long[] expectedOutput)364 private static void testSortDescending( 365 long[] input, int fromIndex, int toIndex, long[] expectedOutput) { 366 input = Arrays.copyOf(input, input.length); 367 Longs.sortDescending(input, fromIndex, toIndex); 368 assertTrue(Arrays.equals(expectedOutput, input)); 369 } 370 testSortDescendingIndexed()371 public void testSortDescendingIndexed() { 372 testSortDescending(new long[] {}, 0, 0, new long[] {}); 373 testSortDescending(new long[] {1}, 0, 1, new long[] {1}); 374 testSortDescending(new long[] {1, 2}, 0, 2, new long[] {2, 1}); 375 testSortDescending(new long[] {1, 3, 1}, 0, 2, new long[] {3, 1, 1}); 376 testSortDescending(new long[] {1, 3, 1}, 0, 1, new long[] {1, 3, 1}); 377 testSortDescending(new long[] {-1, -2, 1, 2}, 1, 3, new long[] {-1, 1, -2, 2}); 378 } 379 380 @GwtIncompatible // SerializableTester testStringConverterSerialization()381 public void testStringConverterSerialization() { 382 SerializableTester.reserializeAndAssert(Longs.stringConverter()); 383 } 384 testToArray()385 public void testToArray() { 386 // need explicit type parameter to avoid javac warning!? 387 List<Long> none = Arrays.<Long>asList(); 388 assertTrue(Arrays.equals(EMPTY, Longs.toArray(none))); 389 390 List<Long> one = Arrays.asList((long) 1); 391 assertTrue(Arrays.equals(ARRAY1, Longs.toArray(one))); 392 393 long[] array = {(long) 0, (long) 1, 0x0FF1C1AL}; 394 395 List<Long> three = Arrays.asList((long) 0, (long) 1, 0x0FF1C1AL); 396 assertTrue(Arrays.equals(array, Longs.toArray(three))); 397 398 assertTrue(Arrays.equals(array, Longs.toArray(Longs.asList(array)))); 399 } 400 testToArray_threadSafe()401 public void testToArray_threadSafe() { 402 for (int delta : new int[] {+1, 0, -1}) { 403 for (int i = 0; i < VALUES.length; i++) { 404 List<Long> list = Longs.asList(VALUES).subList(0, i); 405 Collection<Long> misleadingSize = Helpers.misleadingSizeCollection(delta); 406 misleadingSize.addAll(list); 407 long[] arr = Longs.toArray(misleadingSize); 408 assertEquals(i, arr.length); 409 for (int j = 0; j < i; j++) { 410 assertEquals(VALUES[j], arr[j]); 411 } 412 } 413 } 414 } 415 testToArray_withNull()416 public void testToArray_withNull() { 417 List<Long> list = Arrays.asList((long) 0, (long) 1, null); 418 try { 419 Longs.toArray(list); 420 fail(); 421 } catch (NullPointerException expected) { 422 } 423 } 424 testToArray_withConversion()425 public void testToArray_withConversion() { 426 long[] array = {(long) 0, (long) 1, (long) 2}; 427 428 List<Byte> bytes = Arrays.asList((byte) 0, (byte) 1, (byte) 2); 429 List<Short> shorts = Arrays.asList((short) 0, (short) 1, (short) 2); 430 List<Integer> ints = Arrays.asList(0, 1, 2); 431 List<Float> floats = Arrays.asList((float) 0, (float) 1, (float) 2); 432 List<Long> longs = Arrays.asList((long) 0, (long) 1, (long) 2); 433 List<Double> doubles = Arrays.asList((double) 0, (double) 1, (double) 2); 434 435 assertTrue(Arrays.equals(array, Longs.toArray(bytes))); 436 assertTrue(Arrays.equals(array, Longs.toArray(shorts))); 437 assertTrue(Arrays.equals(array, Longs.toArray(ints))); 438 assertTrue(Arrays.equals(array, Longs.toArray(floats))); 439 assertTrue(Arrays.equals(array, Longs.toArray(longs))); 440 assertTrue(Arrays.equals(array, Longs.toArray(doubles))); 441 } 442 testAsList_isAView()443 public void testAsList_isAView() { 444 long[] array = {(long) 0, (long) 1}; 445 List<Long> list = Longs.asList(array); 446 list.set(0, (long) 2); 447 assertTrue(Arrays.equals(new long[] {(long) 2, (long) 1}, array)); 448 array[1] = (long) 3; 449 assertEquals(Arrays.asList((long) 2, (long) 3), list); 450 } 451 testAsList_toArray_roundTrip()452 public void testAsList_toArray_roundTrip() { 453 long[] array = {(long) 0, (long) 1, (long) 2}; 454 List<Long> list = Longs.asList(array); 455 long[] newArray = Longs.toArray(list); 456 457 // Make sure it returned a copy 458 list.set(0, (long) 4); 459 assertTrue(Arrays.equals(new long[] {(long) 0, (long) 1, (long) 2}, newArray)); 460 newArray[1] = (long) 5; 461 assertEquals((long) 1, (long) list.get(1)); 462 } 463 464 // This test stems from a real bug found by andrewk testAsList_subList_toArray_roundTrip()465 public void testAsList_subList_toArray_roundTrip() { 466 long[] array = {(long) 0, (long) 1, (long) 2, (long) 3}; 467 List<Long> list = Longs.asList(array); 468 assertTrue(Arrays.equals(new long[] {(long) 1, (long) 2}, Longs.toArray(list.subList(1, 3)))); 469 assertTrue(Arrays.equals(new long[] {}, Longs.toArray(list.subList(2, 2)))); 470 } 471 testAsListEmpty()472 public void testAsListEmpty() { 473 assertSame(Collections.emptyList(), Longs.asList(EMPTY)); 474 } 475 476 @GwtIncompatible // NullPointerTester testNulls()477 public void testNulls() { 478 new NullPointerTester().testAllPublicStaticMethods(Longs.class); 479 } 480 testStringConverter_convert()481 public void testStringConverter_convert() { 482 Converter<String, Long> converter = Longs.stringConverter(); 483 assertEquals((Long) 1L, converter.convert("1")); 484 assertEquals((Long) 0L, converter.convert("0")); 485 assertEquals((Long) (-1L), converter.convert("-1")); 486 assertEquals((Long) 255L, converter.convert("0xff")); 487 assertEquals((Long) 255L, converter.convert("0xFF")); 488 assertEquals((Long) (-255L), converter.convert("-0xFF")); 489 assertEquals((Long) 255L, converter.convert("#0000FF")); 490 assertEquals((Long) 438L, converter.convert("0666")); 491 } 492 testStringConverter_convertError()493 public void testStringConverter_convertError() { 494 try { 495 Longs.stringConverter().convert("notanumber"); 496 fail(); 497 } catch (NumberFormatException expected) { 498 } 499 } 500 testStringConverter_nullConversions()501 public void testStringConverter_nullConversions() { 502 assertNull(Longs.stringConverter().convert(null)); 503 assertNull(Longs.stringConverter().reverse().convert(null)); 504 } 505 testStringConverter_reverse()506 public void testStringConverter_reverse() { 507 Converter<String, Long> converter = Longs.stringConverter(); 508 assertEquals("1", converter.reverse().convert(1L)); 509 assertEquals("0", converter.reverse().convert(0L)); 510 assertEquals("-1", converter.reverse().convert(-1L)); 511 assertEquals("255", converter.reverse().convert(0xffL)); 512 assertEquals("255", converter.reverse().convert(0xFFL)); 513 assertEquals("-255", converter.reverse().convert(-0xFFL)); 514 assertEquals("438", converter.reverse().convert(0666L)); 515 } 516 517 @GwtIncompatible // NullPointerTester testStringConverter_nullPointerTester()518 public void testStringConverter_nullPointerTester() throws Exception { 519 NullPointerTester tester = new NullPointerTester(); 520 tester.testAllPublicInstanceMethods(Longs.stringConverter()); 521 } 522 testTryParse()523 public void testTryParse() { 524 tryParseAndAssertEquals(0L, "0"); 525 tryParseAndAssertEquals(0L, "-0"); 526 tryParseAndAssertEquals(1L, "1"); 527 tryParseAndAssertEquals(-1L, "-1"); 528 tryParseAndAssertEquals(8900L, "8900"); 529 tryParseAndAssertEquals(-8900L, "-8900"); 530 tryParseAndAssertEquals(MAX_VALUE, Long.toString(MAX_VALUE)); 531 tryParseAndAssertEquals(MIN_VALUE, Long.toString(MIN_VALUE)); 532 assertNull(Longs.tryParse("")); 533 assertNull(Longs.tryParse("-")); 534 assertNull(Longs.tryParse("+1")); 535 assertNull(Longs.tryParse("999999999999999999999999")); 536 assertNull( 537 "Max long + 1", 538 Longs.tryParse(BigInteger.valueOf(MAX_VALUE).add(BigInteger.ONE).toString())); 539 assertNull( 540 "Max long * 10", 541 Longs.tryParse(BigInteger.valueOf(MAX_VALUE).multiply(BigInteger.TEN).toString())); 542 assertNull( 543 "Min long - 1", 544 Longs.tryParse(BigInteger.valueOf(MIN_VALUE).subtract(BigInteger.ONE).toString())); 545 assertNull( 546 "Min long * 10", 547 Longs.tryParse(BigInteger.valueOf(MIN_VALUE).multiply(BigInteger.TEN).toString())); 548 assertNull(Longs.tryParse("\u0662\u06f3")); 549 } 550 551 /** 552 * Applies {@link Longs#tryParse(String)} to the given string and asserts that the result is as 553 * expected. 554 */ tryParseAndAssertEquals(Long expected, String value)555 private static void tryParseAndAssertEquals(Long expected, String value) { 556 assertEquals(expected, Longs.tryParse(value)); 557 } 558 testTryParse_radix()559 public void testTryParse_radix() { 560 for (int radix = Character.MIN_RADIX; radix <= Character.MAX_RADIX; radix++) { 561 radixEncodeParseAndAssertEquals((long) 0, radix); 562 radixEncodeParseAndAssertEquals((long) 8000, radix); 563 radixEncodeParseAndAssertEquals((long) -8000, radix); 564 radixEncodeParseAndAssertEquals(MAX_VALUE, radix); 565 radixEncodeParseAndAssertEquals(MIN_VALUE, radix); 566 assertNull("Radix: " + radix, Longs.tryParse("999999999999999999999999", radix)); 567 assertNull( 568 "Radix: " + radix, 569 Longs.tryParse(BigInteger.valueOf(MAX_VALUE).add(BigInteger.ONE).toString(), radix)); 570 assertNull( 571 "Radix: " + radix, 572 Longs.tryParse(BigInteger.valueOf(MIN_VALUE).subtract(BigInteger.ONE).toString(), radix)); 573 } 574 assertNull("Hex string and dec parm", Longs.tryParse("FFFF", 10)); 575 assertEquals("Mixed hex case", 65535, Longs.tryParse("ffFF", 16).longValue()); 576 } 577 578 /** 579 * Encodes the long as a string with given radix, then uses {@link Longs#tryParse(String, int)} to 580 * parse the result. Asserts the result is the same as what we started with. 581 */ radixEncodeParseAndAssertEquals(Long value, int radix)582 private static void radixEncodeParseAndAssertEquals(Long value, int radix) { 583 assertEquals("Radix: " + radix, value, Longs.tryParse(Long.toString(value, radix), radix)); 584 } 585 testTryParse_radixTooBig()586 public void testTryParse_radixTooBig() { 587 try { 588 Longs.tryParse("0", Character.MAX_RADIX + 1); 589 fail(); 590 } catch (IllegalArgumentException expected) { 591 } 592 } 593 testTryParse_radixTooSmall()594 public void testTryParse_radixTooSmall() { 595 try { 596 Longs.tryParse("0", Character.MIN_RADIX - 1); 597 fail(); 598 } catch (IllegalArgumentException expected) { 599 } 600 } 601 testTryParse_withNullGwt()602 public void testTryParse_withNullGwt() { 603 assertNull(Longs.tryParse("null")); 604 try { 605 Longs.tryParse(null); 606 fail("Expected NPE"); 607 } catch (NullPointerException expected) { 608 } 609 } 610 } 611