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 com.google.common.annotations.GwtCompatible; 20 import com.google.common.annotations.GwtIncompatible; 21 import com.google.common.base.Converter; 22 import com.google.common.collect.testing.Helpers; 23 import com.google.common.testing.NullPointerTester; 24 import com.google.common.testing.SerializableTester; 25 26 import junit.framework.TestCase; 27 28 import java.util.Arrays; 29 import java.util.Collection; 30 import java.util.Collections; 31 import java.util.Comparator; 32 import java.util.List; 33 import java.util.Random; 34 35 /** 36 * Unit test for {@link Shorts}. 37 * 38 * @author Kevin Bourrillion 39 */ 40 @GwtCompatible(emulated = true) 41 @SuppressWarnings("cast") // redundant casts are intentional and harmless 42 public class ShortsTest extends TestCase { 43 private static final short[] EMPTY = {}; 44 private static final short[] ARRAY1 = {(short) 1}; 45 private static final short[] ARRAY234 46 = {(short) 2, (short) 3, (short) 4}; 47 48 private static final short LEAST = Short.MIN_VALUE; 49 private static final short GREATEST = Short.MAX_VALUE; 50 51 private static final short[] VALUES = 52 { LEAST, (short) -1, (short) 0, (short) 1, GREATEST }; 53 54 public void testHashCode() { 55 for (short value : VALUES) { 56 assertEquals(((Short) value).hashCode(), Shorts.hashCode(value)); 57 } 58 } 59 60 public void testCheckedCast() { 61 for (short value : VALUES) { 62 assertEquals(value, Shorts.checkedCast((long) value)); 63 } 64 assertCastFails(GREATEST + 1L); 65 assertCastFails(LEAST - 1L); 66 assertCastFails(Long.MAX_VALUE); 67 assertCastFails(Long.MIN_VALUE); 68 } 69 70 public void testSaturatedCast() { 71 for (short value : VALUES) { 72 assertEquals(value, Shorts.saturatedCast((long) value)); 73 } 74 assertEquals(GREATEST, Shorts.saturatedCast(GREATEST + 1L)); 75 assertEquals(LEAST, Shorts.saturatedCast(LEAST - 1L)); 76 assertEquals(GREATEST, Shorts.saturatedCast(Long.MAX_VALUE)); 77 assertEquals(LEAST, Shorts.saturatedCast(Long.MIN_VALUE)); 78 } 79 80 private static void assertCastFails(long value) { 81 try { 82 Shorts.checkedCast(value); 83 fail("Cast to short should have failed: " + value); 84 } catch (IllegalArgumentException ex) { 85 assertTrue(value + " not found in exception text: " + ex.getMessage(), 86 ex.getMessage().contains(String.valueOf(value))); 87 } 88 } 89 90 public void testCompare() { 91 for (short x : VALUES) { 92 for (short y : VALUES) { 93 // Only compare the sign of the result of compareTo(). 94 int expected = Short.valueOf(x).compareTo(y); 95 int actual = Shorts.compare(x, y); 96 if (expected == 0) { 97 assertEquals(x + ", " + y, expected, actual); 98 } else if (expected < 0) { 99 assertTrue(x + ", " + y + " (expected: " + expected + ", actual" + actual + ")", 100 actual < 0); 101 } else { 102 assertTrue(x + ", " + y + " (expected: " + expected + ", actual" + actual + ")", 103 actual > 0); 104 } 105 } 106 } 107 } 108 109 public void testContains() { 110 assertFalse(Shorts.contains(EMPTY, (short) 1)); 111 assertFalse(Shorts.contains(ARRAY1, (short) 2)); 112 assertFalse(Shorts.contains(ARRAY234, (short) 1)); 113 assertTrue(Shorts.contains(new short[] {(short) -1}, (short) -1)); 114 assertTrue(Shorts.contains(ARRAY234, (short) 2)); 115 assertTrue(Shorts.contains(ARRAY234, (short) 3)); 116 assertTrue(Shorts.contains(ARRAY234, (short) 4)); 117 } 118 119 public void testIndexOf() { 120 assertEquals(-1, Shorts.indexOf(EMPTY, (short) 1)); 121 assertEquals(-1, Shorts.indexOf(ARRAY1, (short) 2)); 122 assertEquals(-1, Shorts.indexOf(ARRAY234, (short) 1)); 123 assertEquals(0, Shorts.indexOf( 124 new short[] {(short) -1}, (short) -1)); 125 assertEquals(0, Shorts.indexOf(ARRAY234, (short) 2)); 126 assertEquals(1, Shorts.indexOf(ARRAY234, (short) 3)); 127 assertEquals(2, Shorts.indexOf(ARRAY234, (short) 4)); 128 assertEquals(1, Shorts.indexOf( 129 new short[] { (short) 2, (short) 3, (short) 2, (short) 3 }, 130 (short) 3)); 131 } 132 133 public void testIndexOf_arrayTarget() { 134 assertEquals(0, Shorts.indexOf(EMPTY, EMPTY)); 135 assertEquals(0, Shorts.indexOf(ARRAY234, EMPTY)); 136 assertEquals(-1, Shorts.indexOf(EMPTY, ARRAY234)); 137 assertEquals(-1, Shorts.indexOf(ARRAY234, ARRAY1)); 138 assertEquals(-1, Shorts.indexOf(ARRAY1, ARRAY234)); 139 assertEquals(0, Shorts.indexOf(ARRAY1, ARRAY1)); 140 assertEquals(0, Shorts.indexOf(ARRAY234, ARRAY234)); 141 assertEquals(0, Shorts.indexOf( 142 ARRAY234, new short[] { (short) 2, (short) 3 })); 143 assertEquals(1, Shorts.indexOf( 144 ARRAY234, new short[] { (short) 3, (short) 4 })); 145 assertEquals(1, Shorts.indexOf(ARRAY234, new short[] { (short) 3 })); 146 assertEquals(2, Shorts.indexOf(ARRAY234, new short[] { (short) 4 })); 147 assertEquals(1, Shorts.indexOf(new short[] { (short) 2, (short) 3, 148 (short) 3, (short) 3, (short) 3 }, 149 new short[] { (short) 3 } 150 )); 151 assertEquals(2, Shorts.indexOf( 152 new short[] { (short) 2, (short) 3, (short) 2, 153 (short) 3, (short) 4, (short) 2, (short) 3}, 154 new short[] { (short) 2, (short) 3, (short) 4} 155 )); 156 assertEquals(1, Shorts.indexOf( 157 new short[] { (short) 2, (short) 2, (short) 3, 158 (short) 4, (short) 2, (short) 3, (short) 4}, 159 new short[] { (short) 2, (short) 3, (short) 4} 160 )); 161 assertEquals(-1, Shorts.indexOf( 162 new short[] { (short) 4, (short) 3, (short) 2}, 163 new short[] { (short) 2, (short) 3, (short) 4} 164 )); 165 } 166 167 public void testLastIndexOf() { 168 assertEquals(-1, Shorts.lastIndexOf(EMPTY, (short) 1)); 169 assertEquals(-1, Shorts.lastIndexOf(ARRAY1, (short) 2)); 170 assertEquals(-1, Shorts.lastIndexOf(ARRAY234, (short) 1)); 171 assertEquals(0, Shorts.lastIndexOf( 172 new short[] {(short) -1}, (short) -1)); 173 assertEquals(0, Shorts.lastIndexOf(ARRAY234, (short) 2)); 174 assertEquals(1, Shorts.lastIndexOf(ARRAY234, (short) 3)); 175 assertEquals(2, Shorts.lastIndexOf(ARRAY234, (short) 4)); 176 assertEquals(3, Shorts.lastIndexOf( 177 new short[] { (short) 2, (short) 3, (short) 2, (short) 3 }, 178 (short) 3)); 179 } 180 181 public void testMax_noArgs() { 182 try { 183 Shorts.max(); 184 fail(); 185 } catch (IllegalArgumentException expected) { 186 } 187 } 188 189 public void testMax() { 190 assertEquals(LEAST, Shorts.max(LEAST)); 191 assertEquals(GREATEST, Shorts.max(GREATEST)); 192 assertEquals((short) 9, Shorts.max( 193 (short) 8, (short) 6, (short) 7, 194 (short) 5, (short) 3, (short) 0, (short) 9)); 195 } 196 197 public void testMin_noArgs() { 198 try { 199 Shorts.min(); 200 fail(); 201 } catch (IllegalArgumentException expected) { 202 } 203 } 204 205 public void testMin() { 206 assertEquals(LEAST, Shorts.min(LEAST)); 207 assertEquals(GREATEST, Shorts.min(GREATEST)); 208 assertEquals((short) 0, Shorts.min( 209 (short) 8, (short) 6, (short) 7, 210 (short) 5, (short) 3, (short) 0, (short) 9)); 211 } 212 213 public void testConcat() { 214 assertTrue(Arrays.equals(EMPTY, Shorts.concat())); 215 assertTrue(Arrays.equals(EMPTY, Shorts.concat(EMPTY))); 216 assertTrue(Arrays.equals(EMPTY, Shorts.concat(EMPTY, EMPTY, EMPTY))); 217 assertTrue(Arrays.equals(ARRAY1, Shorts.concat(ARRAY1))); 218 assertNotSame(ARRAY1, Shorts.concat(ARRAY1)); 219 assertTrue(Arrays.equals(ARRAY1, Shorts.concat(EMPTY, ARRAY1, EMPTY))); 220 assertTrue(Arrays.equals( 221 new short[] {(short) 1, (short) 1, (short) 1}, 222 Shorts.concat(ARRAY1, ARRAY1, ARRAY1))); 223 assertTrue(Arrays.equals( 224 new short[] {(short) 1, (short) 2, (short) 3, (short) 4}, 225 Shorts.concat(ARRAY1, ARRAY234))); 226 } 227 228 @GwtIncompatible("Shorts.toByteArray") 229 public void testToByteArray() { 230 assertTrue(Arrays.equals( 231 new byte[] {0x23, 0x45}, Shorts.toByteArray((short) 0x2345))); 232 assertTrue(Arrays.equals( 233 new byte[] {(byte) 0xFE, (byte) 0xDC}, 234 Shorts.toByteArray((short) 0xFEDC))); 235 } 236 237 @GwtIncompatible("Shorts.fromByteArray") 238 public void testFromByteArray() { 239 assertEquals((short) 0x2345, 240 Shorts.fromByteArray(new byte[] {0x23, 0x45})); 241 assertEquals((short) 0xFEDC, Shorts.fromByteArray( 242 new byte[] {(byte) 0xFE, (byte) 0xDC})); 243 244 try { 245 Shorts.fromByteArray(new byte[] {0x01}); 246 fail(); 247 } catch (IllegalArgumentException expected) { 248 } 249 } 250 251 @GwtIncompatible("Shorts.fromBytes") 252 public void testFromBytes() { 253 assertEquals((short) 0x2345, Shorts.fromBytes((byte) 0x23, (byte) 0x45)); 254 assertEquals((short) 0xFEDC, Shorts.fromBytes((byte) 0xFE, (byte) 0xDC)); 255 } 256 257 @GwtIncompatible("Shorts.fromByteArray, Shorts.toByteArray") 258 public void testByteArrayRoundTrips() { 259 Random r = new Random(5); 260 byte[] b = new byte[Shorts.BYTES]; 261 262 // total overkill, but, it takes 0.1 sec so why not... 263 for (int i = 0; i < 10000; i++) { 264 short num = (short) r.nextInt(); 265 assertEquals(num, Shorts.fromByteArray(Shorts.toByteArray(num))); 266 267 r.nextBytes(b); 268 assertTrue(Arrays.equals(b, 269 Shorts.toByteArray(Shorts.fromByteArray(b)))); 270 } 271 } 272 273 public void testEnsureCapacity() { 274 assertSame(EMPTY, Shorts.ensureCapacity(EMPTY, 0, 1)); 275 assertSame(ARRAY1, Shorts.ensureCapacity(ARRAY1, 0, 1)); 276 assertSame(ARRAY1, Shorts.ensureCapacity(ARRAY1, 1, 1)); 277 assertTrue(Arrays.equals( 278 new short[] {(short) 1, (short) 0, (short) 0}, 279 Shorts.ensureCapacity(ARRAY1, 2, 1))); 280 } 281 282 public void testEnsureCapacity_fail() { 283 try { 284 Shorts.ensureCapacity(ARRAY1, -1, 1); 285 fail(); 286 } catch (IllegalArgumentException expected) { 287 } 288 try { 289 // notice that this should even fail when no growth was needed 290 Shorts.ensureCapacity(ARRAY1, 1, -1); 291 fail(); 292 } catch (IllegalArgumentException expected) { 293 } 294 } 295 296 public void testJoin() { 297 assertEquals("", Shorts.join(",", EMPTY)); 298 assertEquals("1", Shorts.join(",", ARRAY1)); 299 assertEquals("1,2", Shorts.join(",", (short) 1, (short) 2)); 300 assertEquals("123", 301 Shorts.join("", (short) 1, (short) 2, (short) 3)); 302 } 303 304 public void testLexicographicalComparator() { 305 List<short[]> ordered = Arrays.asList( 306 new short[] {}, 307 new short[] {LEAST}, 308 new short[] {LEAST, LEAST}, 309 new short[] {LEAST, (short) 1}, 310 new short[] {(short) 1}, 311 new short[] {(short) 1, LEAST}, 312 new short[] {GREATEST, GREATEST - (short) 1}, 313 new short[] {GREATEST, GREATEST}, 314 new short[] {GREATEST, GREATEST, GREATEST}); 315 316 Comparator<short[]> comparator = Shorts.lexicographicalComparator(); 317 Helpers.testComparator(comparator, ordered); 318 } 319 320 @GwtIncompatible("SerializableTester") 321 public void testLexicographicalComparatorSerializable() { 322 Comparator<short[]> comparator = Shorts.lexicographicalComparator(); 323 assertSame(comparator, SerializableTester.reserialize(comparator)); 324 } 325 326 @GwtIncompatible("SerializableTester") 327 public void testStringConverterSerialization() { 328 SerializableTester.reserializeAndAssert(Shorts.stringConverter()); 329 } 330 331 public void testToArray() { 332 // need explicit type parameter to avoid javac warning!? 333 List<Short> none = Arrays.<Short>asList(); 334 assertTrue(Arrays.equals(EMPTY, Shorts.toArray(none))); 335 336 List<Short> one = Arrays.asList((short) 1); 337 assertTrue(Arrays.equals(ARRAY1, Shorts.toArray(one))); 338 339 short[] array = {(short) 0, (short) 1, (short) 3}; 340 341 List<Short> three = Arrays.asList((short) 0, (short) 1, (short) 3); 342 assertTrue(Arrays.equals(array, Shorts.toArray(three))); 343 344 assertTrue(Arrays.equals(array, Shorts.toArray(Shorts.asList(array)))); 345 } 346 347 public void testToArray_threadSafe() { 348 for (int delta : new int[] { +1, 0, -1 }) { 349 for (int i = 0; i < VALUES.length; i++) { 350 List<Short> list = Shorts.asList(VALUES).subList(0, i); 351 Collection<Short> misleadingSize = 352 Helpers.misleadingSizeCollection(delta); 353 misleadingSize.addAll(list); 354 short[] arr = Shorts.toArray(misleadingSize); 355 assertEquals(i, arr.length); 356 for (int j = 0; j < i; j++) { 357 assertEquals(VALUES[j], arr[j]); 358 } 359 } 360 } 361 } 362 363 public void testToArray_withNull() { 364 List<Short> list = Arrays.asList((short) 0, (short) 1, null); 365 try { 366 Shorts.toArray(list); 367 fail(); 368 } catch (NullPointerException expected) { 369 } 370 } 371 372 public void testToArray_withConversion() { 373 short[] array = {(short) 0, (short) 1, (short) 2}; 374 375 List<Byte> bytes = Arrays.asList((byte) 0, (byte) 1, (byte) 2); 376 List<Short> shorts = Arrays.asList((short) 0, (short) 1, (short) 2); 377 List<Integer> ints = Arrays.asList(0, 1, 2); 378 List<Float> floats = Arrays.asList((float) 0, (float) 1, (float) 2); 379 List<Long> longs = Arrays.asList((long) 0, (long) 1, (long) 2); 380 List<Double> doubles = Arrays.asList((double) 0, (double) 1, (double) 2); 381 382 assertTrue(Arrays.equals(array, Shorts.toArray(bytes))); 383 assertTrue(Arrays.equals(array, Shorts.toArray(shorts))); 384 assertTrue(Arrays.equals(array, Shorts.toArray(ints))); 385 assertTrue(Arrays.equals(array, Shorts.toArray(floats))); 386 assertTrue(Arrays.equals(array, Shorts.toArray(longs))); 387 assertTrue(Arrays.equals(array, Shorts.toArray(doubles))); 388 } 389 390 public void testAsList_isAView() { 391 short[] array = {(short) 0, (short) 1}; 392 List<Short> list = Shorts.asList(array); 393 list.set(0, (short) 2); 394 assertTrue(Arrays.equals(new short[] {(short) 2, (short) 1}, array)); 395 array[1] = (short) 3; 396 assertEquals(Arrays.asList((short) 2, (short) 3), list); 397 } 398 399 public void testAsList_toArray_roundTrip() { 400 short[] array = { (short) 0, (short) 1, (short) 2 }; 401 List<Short> list = Shorts.asList(array); 402 short[] newArray = Shorts.toArray(list); 403 404 // Make sure it returned a copy 405 list.set(0, (short) 4); 406 assertTrue(Arrays.equals( 407 new short[] { (short) 0, (short) 1, (short) 2 }, newArray)); 408 newArray[1] = (short) 5; 409 assertEquals((short) 1, (short) list.get(1)); 410 } 411 412 // This test stems from a real bug found by andrewk 413 public void testAsList_subList_toArray_roundTrip() { 414 short[] array = { (short) 0, (short) 1, (short) 2, (short) 3 }; 415 List<Short> list = Shorts.asList(array); 416 assertTrue(Arrays.equals(new short[] { (short) 1, (short) 2 }, 417 Shorts.toArray(list.subList(1, 3)))); 418 assertTrue(Arrays.equals(new short[] {}, 419 Shorts.toArray(list.subList(2, 2)))); 420 } 421 422 public void testAsListEmpty() { 423 assertSame(Collections.emptyList(), Shorts.asList(EMPTY)); 424 } 425 426 @GwtIncompatible("NullPointerTester") 427 public void testNulls() { 428 new NullPointerTester().testAllPublicStaticMethods(Shorts.class); 429 } 430 431 public void testStringConverter_convert() { 432 Converter<String, Short> converter = Shorts.stringConverter(); 433 assertEquals((Short) (short) 1, converter.convert("1")); 434 assertEquals((Short) (short) 0, converter.convert("0")); 435 assertEquals((Short) (short) (-1), converter.convert("-1")); 436 assertEquals((Short) (short) 255, converter.convert("0xff")); 437 assertEquals((Short) (short) 255, converter.convert("0xFF")); 438 assertEquals((Short) (short) (-255), converter.convert("-0xFF")); 439 assertEquals((Short) (short) 255, converter.convert("#0000FF")); 440 assertEquals((Short) (short) 438, converter.convert("0666")); 441 } 442 443 public void testStringConverter_convertError() { 444 try { 445 Shorts.stringConverter().convert("notanumber"); 446 fail(); 447 } catch (NumberFormatException expected) { 448 } 449 } 450 451 public void testStringConverter_nullConversions() { 452 assertNull(Shorts.stringConverter().convert(null)); 453 assertNull(Shorts.stringConverter().reverse().convert(null)); 454 } 455 456 public void testStringConverter_reverse() { 457 Converter<String, Short> converter = Shorts.stringConverter(); 458 assertEquals("1", converter.reverse().convert((short) 1)); 459 assertEquals("0", converter.reverse().convert((short) 0)); 460 assertEquals("-1", converter.reverse().convert((short) -1)); 461 assertEquals("255", converter.reverse().convert((short) 0xff)); 462 assertEquals("255", converter.reverse().convert((short) 0xFF)); 463 assertEquals("-255", converter.reverse().convert((short) -0xFF)); 464 assertEquals("438", converter.reverse().convert((short) 0666)); 465 } 466 467 @GwtIncompatible("NullPointerTester") 468 public void testStringConverter_nullPointerTester() throws Exception { 469 NullPointerTester tester = new NullPointerTester(); 470 tester.testAllPublicInstanceMethods(Shorts.stringConverter()); 471 } 472 } 473
