BytesTest.java revision 1d580d0f6ee4f21eb309ba7b509d2c6d671c4044 
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.collect.testing.Helpers;
22import com.google.common.testing.NullPointerTester;
23
24import junit.framework.TestCase;
25
26import java.util.Arrays;
27import java.util.Collection;
28import java.util.Collections;
29import java.util.List;
30
31/**
32 * Unit test for {@link Bytes}.
33 *
34 * @author Kevin Bourrillion
35 */
36@GwtCompatible(emulated = true)
37public class BytesTest extends TestCase {
38  private static final byte[] EMPTY = {};
39  private static final byte[] ARRAY1 = {(byte) 1};
40  private static final byte[] ARRAY234
41      = {(byte) 2, (byte) 3, (byte) 4};
42
43  private static final byte[] VALUES =
44      { Byte.MIN_VALUE, -1, 0, 1, Byte.MAX_VALUE };
45
46  public void testHashCode() {
47    for (byte value : VALUES) {
48      assertEquals(((Byte) value).hashCode(), Bytes.hashCode(value));
49    }
50  }
51
52  public void testContains() {
53    assertFalse(Bytes.contains(EMPTY, (byte) 1));
54    assertFalse(Bytes.contains(ARRAY1, (byte) 2));
55    assertFalse(Bytes.contains(ARRAY234, (byte) 1));
56    assertTrue(Bytes.contains(new byte[] {(byte) -1}, (byte) -1));
57    assertTrue(Bytes.contains(ARRAY234, (byte) 2));
58    assertTrue(Bytes.contains(ARRAY234, (byte) 3));
59    assertTrue(Bytes.contains(ARRAY234, (byte) 4));
60  }
61
62  public void testIndexOf() {
63    assertEquals(-1, Bytes.indexOf(EMPTY, (byte) 1));
64    assertEquals(-1, Bytes.indexOf(ARRAY1, (byte) 2));
65    assertEquals(-1, Bytes.indexOf(ARRAY234, (byte) 1));
66    assertEquals(0, Bytes.indexOf(
67        new byte[] {(byte) -1}, (byte) -1));
68    assertEquals(0, Bytes.indexOf(ARRAY234, (byte) 2));
69    assertEquals(1, Bytes.indexOf(ARRAY234, (byte) 3));
70    assertEquals(2, Bytes.indexOf(ARRAY234, (byte) 4));
71    assertEquals(1, Bytes.indexOf(
72        new byte[] { (byte) 2, (byte) 3, (byte) 2, (byte) 3 },
73        (byte) 3));
74  }
75
76  public void testIndexOf_arrayTarget() {
77    assertEquals(0, Bytes.indexOf(EMPTY, EMPTY));
78    assertEquals(0, Bytes.indexOf(ARRAY234, EMPTY));
79    assertEquals(-1, Bytes.indexOf(EMPTY, ARRAY234));
80    assertEquals(-1, Bytes.indexOf(ARRAY234, ARRAY1));
81    assertEquals(-1, Bytes.indexOf(ARRAY1, ARRAY234));
82    assertEquals(0, Bytes.indexOf(ARRAY1, ARRAY1));
83    assertEquals(0, Bytes.indexOf(ARRAY234, ARRAY234));
84    assertEquals(0, Bytes.indexOf(
85        ARRAY234, new byte[] { (byte) 2, (byte) 3 }));
86    assertEquals(1, Bytes.indexOf(
87        ARRAY234, new byte[] { (byte) 3, (byte) 4 }));
88    assertEquals(1, Bytes.indexOf(ARRAY234, new byte[] { (byte) 3 }));
89    assertEquals(2, Bytes.indexOf(ARRAY234, new byte[] { (byte) 4 }));
90    assertEquals(1, Bytes.indexOf(new byte[] { (byte) 2, (byte) 3,
91        (byte) 3, (byte) 3, (byte) 3 },
92        new byte[] { (byte) 3 }
93    ));
94    assertEquals(2, Bytes.indexOf(
95        new byte[] { (byte) 2, (byte) 3, (byte) 2,
96            (byte) 3, (byte) 4, (byte) 2, (byte) 3},
97        new byte[] { (byte) 2, (byte) 3, (byte) 4}
98    ));
99    assertEquals(1, Bytes.indexOf(
100        new byte[] { (byte) 2, (byte) 2, (byte) 3,
101            (byte) 4, (byte) 2, (byte) 3, (byte) 4},
102        new byte[] { (byte) 2, (byte) 3, (byte) 4}
103    ));
104    assertEquals(-1, Bytes.indexOf(
105        new byte[] { (byte) 4, (byte) 3, (byte) 2},
106        new byte[] { (byte) 2, (byte) 3, (byte) 4}
107    ));
108  }
109
110  public void testLastIndexOf() {
111    assertEquals(-1, Bytes.lastIndexOf(EMPTY, (byte) 1));
112    assertEquals(-1, Bytes.lastIndexOf(ARRAY1, (byte) 2));
113    assertEquals(-1, Bytes.lastIndexOf(ARRAY234, (byte) 1));
114    assertEquals(0, Bytes.lastIndexOf(
115        new byte[] {(byte) -1}, (byte) -1));
116    assertEquals(0, Bytes.lastIndexOf(ARRAY234, (byte) 2));
117    assertEquals(1, Bytes.lastIndexOf(ARRAY234, (byte) 3));
118    assertEquals(2, Bytes.lastIndexOf(ARRAY234, (byte) 4));
119    assertEquals(3, Bytes.lastIndexOf(
120        new byte[] { (byte) 2, (byte) 3, (byte) 2, (byte) 3 },
121        (byte) 3));
122  }
123
124  public void testConcat() {
125    assertTrue(Arrays.equals(EMPTY, Bytes.concat()));
126    assertTrue(Arrays.equals(EMPTY, Bytes.concat(EMPTY)));
127    assertTrue(Arrays.equals(EMPTY, Bytes.concat(EMPTY, EMPTY, EMPTY)));
128    assertTrue(Arrays.equals(ARRAY1, Bytes.concat(ARRAY1)));
129    assertNotSame(ARRAY1, Bytes.concat(ARRAY1));
130    assertTrue(Arrays.equals(ARRAY1, Bytes.concat(EMPTY, ARRAY1, EMPTY)));
131    assertTrue(Arrays.equals(
132        new byte[] {(byte) 1, (byte) 1, (byte) 1},
133        Bytes.concat(ARRAY1, ARRAY1, ARRAY1)));
134    assertTrue(Arrays.equals(
135        new byte[] {(byte) 1, (byte) 2, (byte) 3, (byte) 4},
136        Bytes.concat(ARRAY1, ARRAY234)));
137  }
138
139  public void testEnsureCapacity() {
140    assertSame(EMPTY, Bytes.ensureCapacity(EMPTY, 0, 1));
141    assertSame(ARRAY1, Bytes.ensureCapacity(ARRAY1, 0, 1));
142    assertSame(ARRAY1, Bytes.ensureCapacity(ARRAY1, 1, 1));
143    assertTrue(Arrays.equals(
144        new byte[] {(byte) 1, (byte) 0, (byte) 0},
145        Bytes.ensureCapacity(ARRAY1, 2, 1)));
146  }
147
148  public void testEnsureCapacity_fail() {
149    try {
150      Bytes.ensureCapacity(ARRAY1, -1, 1);
151      fail();
152    } catch (IllegalArgumentException expected) {
153    }
154    try {
155      // notice that this should even fail when no growth was needed
156      Bytes.ensureCapacity(ARRAY1, 1, -1);
157      fail();
158    } catch (IllegalArgumentException expected) {
159    }
160  }
161
162  public void testToArray() {
163    // need explicit type parameter to avoid javac warning!?
164    List<Byte> none = Arrays.<Byte>asList();
165    assertTrue(Arrays.equals(EMPTY, Bytes.toArray(none)));
166
167    List<Byte> one = Arrays.asList((byte) 1);
168    assertTrue(Arrays.equals(ARRAY1, Bytes.toArray(one)));
169
170    byte[] array = {(byte) 0, (byte) 1, (byte) 0x55};
171
172    List<Byte> three = Arrays.asList((byte) 0, (byte) 1, (byte) 0x55);
173    assertTrue(Arrays.equals(array, Bytes.toArray(three)));
174
175    assertTrue(Arrays.equals(array, Bytes.toArray(Bytes.asList(array))));
176  }
177
178  public void testToArray_threadSafe() {
179    for (int delta : new int[] { +1, 0, -1 }) {
180      for (int i = 0; i < VALUES.length; i++) {
181        List<Byte> list = Bytes.asList(VALUES).subList(0, i);
182        Collection<Byte> misleadingSize =
183            Helpers.misleadingSizeCollection(delta);
184        misleadingSize.addAll(list);
185        byte[] arr = Bytes.toArray(misleadingSize);
186        assertEquals(i, arr.length);
187        for (int j = 0; j < i; j++) {
188          assertEquals(VALUES[j], arr[j]);
189        }
190      }
191    }
192  }
193
194  public void testToArray_withNull() {
195    List<Byte> list = Arrays.asList((byte) 0, (byte) 1, null);
196    try {
197      Bytes.toArray(list);
198      fail();
199    } catch (NullPointerException expected) {
200    }
201  }
202
203  public void testAsList_isAView() {
204    byte[] array = {(byte) 0, (byte) 1};
205    List<Byte> list = Bytes.asList(array);
206    list.set(0, (byte) 2);
207    assertTrue(Arrays.equals(new byte[] {(byte) 2, (byte) 1}, array));
208    array[1] = (byte) 3;
209    assertEquals(Arrays.asList((byte) 2, (byte) 3), list);
210  }
211
212  public void testAsList_toArray_roundTrip() {
213    byte[] array = { (byte) 0, (byte) 1, (byte) 2 };
214    List<Byte> list = Bytes.asList(array);
215    byte[] newArray = Bytes.toArray(list);
216
217    // Make sure it returned a copy
218    list.set(0, (byte) 4);
219    assertTrue(Arrays.equals(
220        new byte[] { (byte) 0, (byte) 1, (byte) 2 }, newArray));
221    newArray[1] = (byte) 5;
222    assertEquals((byte) 1, (byte) list.get(1));
223  }
224
225  // This test stems from a real bug found by andrewk
226  public void testAsList_subList_toArray_roundTrip() {
227    byte[] array = { (byte) 0, (byte) 1, (byte) 2, (byte) 3 };
228    List<Byte> list = Bytes.asList(array);
229    assertTrue(Arrays.equals(new byte[] { (byte) 1, (byte) 2 },
230        Bytes.toArray(list.subList(1, 3))));
231    assertTrue(Arrays.equals(new byte[] {},
232        Bytes.toArray(list.subList(2, 2))));
233  }
234
235  public void testAsListEmpty() {
236    assertSame(Collections.emptyList(), Bytes.asList(EMPTY));
237  }
238
239  @GwtIncompatible("NullPointerTester")
240  public void testNulls() throws Exception {
241    NullPointerTester tester = new NullPointerTester();
242    tester.setDefault(byte[].class, new byte[0]);
243    tester.testAllPublicStaticMethods(Bytes.class);
244  }
245}
246