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
17package com.google.common.primitives;
18
19import com.google.common.annotations.GwtCompatible;
20import com.google.common.annotations.GwtIncompatible;
21import com.google.common.base.Converter;
22import com.google.common.collect.testing.Helpers;
23import com.google.common.testing.NullPointerTester;
24import com.google.common.testing.SerializableTester;
25
26import junit.framework.TestCase;
27
28import java.util.Arrays;
29import java.util.Collection;
30import java.util.Collections;
31import java.util.Comparator;
32import java.util.List;
33import 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
42public 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