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;
23import com.google.common.testing.SerializableTester;
24
25import junit.framework.TestCase;
26
27import java.util.Arrays;
28import java.util.Collection;
29import java.util.Collections;
30import java.util.Comparator;
31import java.util.List;
32
33/**
34 * Unit test for {@link Booleans}.
35 *
36 * @author Kevin Bourrillion
37 */
38@GwtCompatible(emulated = true)
39public class BooleansTest extends TestCase {
40  private static final boolean[] EMPTY = {};
41  private static final boolean[] ARRAY_FALSE = {false};
42  private static final boolean[] ARRAY_TRUE = {true};
43  private static final boolean[] ARRAY_FALSE_FALSE = {false, false};
44  private static final boolean[] ARRAY_FALSE_TRUE = {false, true};
45
46  private static final boolean[] VALUES = {false, true};
47
48  public void testHashCode() {
49    assertEquals(Boolean.TRUE.hashCode(), Booleans.hashCode(true));
50    assertEquals(Boolean.FALSE.hashCode(), Booleans.hashCode(false));
51  }
52
53  public void testCompare() {
54    for (boolean x : VALUES) {
55      for (boolean y : VALUES) {
56        // note: spec requires only that the sign is the same
57        assertEquals(x + ", " + y,
58                     Boolean.valueOf(x).compareTo(y),
59                     Booleans.compare(x, y));
60      }
61    }
62  }
63
64  public void testContains() {
65    assertFalse(Booleans.contains(EMPTY, false));
66    assertFalse(Booleans.contains(ARRAY_FALSE, true));
67    assertTrue(Booleans.contains(ARRAY_FALSE, false));
68    assertTrue(Booleans.contains(ARRAY_FALSE_TRUE, false));
69    assertTrue(Booleans.contains(ARRAY_FALSE_TRUE, true));
70  }
71
72  public void testIndexOf() {
73    assertEquals(-1, Booleans.indexOf(EMPTY, ARRAY_FALSE));
74    assertEquals(-1, Booleans.indexOf(ARRAY_FALSE, ARRAY_FALSE_TRUE));
75    assertEquals(0, Booleans.indexOf(ARRAY_FALSE_FALSE, ARRAY_FALSE));
76    assertEquals(0, Booleans.indexOf(ARRAY_FALSE, ARRAY_FALSE));
77    assertEquals(0, Booleans.indexOf(ARRAY_FALSE_TRUE, ARRAY_FALSE));
78    assertEquals(1, Booleans.indexOf(ARRAY_FALSE_TRUE, ARRAY_TRUE));
79    assertEquals(0, Booleans.indexOf(ARRAY_TRUE, new boolean[0]));
80  }
81
82  public void testIndexOf_arrays() {
83    assertEquals(-1, Booleans.indexOf(EMPTY, false));
84    assertEquals(-1, Booleans.indexOf(ARRAY_FALSE, true));
85    assertEquals(-1, Booleans.indexOf(ARRAY_FALSE_FALSE, true));
86    assertEquals(0, Booleans.indexOf(ARRAY_FALSE, false));
87    assertEquals(0, Booleans.indexOf(ARRAY_FALSE_TRUE, false));
88    assertEquals(1, Booleans.indexOf(ARRAY_FALSE_TRUE, true));
89    assertEquals(2, Booleans.indexOf(new boolean[] {false, false, true}, true));
90  }
91
92  public void testLastIndexOf() {
93    assertEquals(-1, Booleans.lastIndexOf(EMPTY, false));
94    assertEquals(-1, Booleans.lastIndexOf(ARRAY_FALSE, true));
95    assertEquals(-1, Booleans.lastIndexOf(ARRAY_FALSE_FALSE, true));
96    assertEquals(0, Booleans.lastIndexOf(ARRAY_FALSE, false));
97    assertEquals(0, Booleans.lastIndexOf(ARRAY_FALSE_TRUE, false));
98    assertEquals(1, Booleans.lastIndexOf(ARRAY_FALSE_TRUE, true));
99    assertEquals(2, Booleans.lastIndexOf(new boolean[] {false, true, true}, true));
100  }
101
102  public void testConcat() {
103    assertTrue(Arrays.equals(EMPTY, Booleans.concat()));
104    assertTrue(Arrays.equals(EMPTY, Booleans.concat(EMPTY)));
105    assertTrue(Arrays.equals(EMPTY, Booleans.concat(EMPTY, EMPTY, EMPTY)));
106    assertTrue(Arrays.equals(ARRAY_FALSE, Booleans.concat(ARRAY_FALSE)));
107    assertNotSame(ARRAY_FALSE, Booleans.concat(ARRAY_FALSE));
108    assertTrue(Arrays.equals(ARRAY_FALSE, Booleans.concat(EMPTY, ARRAY_FALSE, EMPTY)));
109    assertTrue(Arrays.equals(
110        new boolean[] {false, false, false},
111        Booleans.concat(ARRAY_FALSE, ARRAY_FALSE, ARRAY_FALSE)));
112    assertTrue(Arrays.equals(
113        new boolean[] {false, false, true},
114        Booleans.concat(ARRAY_FALSE, ARRAY_FALSE_TRUE)));
115  }
116
117  public void testEnsureCapacity() {
118    assertSame(EMPTY, Booleans.ensureCapacity(EMPTY, 0, 1));
119    assertSame(ARRAY_FALSE, Booleans.ensureCapacity(ARRAY_FALSE, 0, 1));
120    assertSame(ARRAY_FALSE, Booleans.ensureCapacity(ARRAY_FALSE, 1, 1));
121    assertTrue(Arrays.equals(
122        new boolean[] {true, false, false},
123        Booleans.ensureCapacity(new boolean[] {true}, 2, 1)));
124  }
125
126  public void testEnsureCapacity_fail() {
127    try {
128      Booleans.ensureCapacity(ARRAY_FALSE, -1, 1);
129      fail();
130    } catch (IllegalArgumentException expected) {
131    }
132    try {
133      // notice that this should even fail when no growth was needed
134      Booleans.ensureCapacity(ARRAY_FALSE, 1, -1);
135      fail();
136    } catch (IllegalArgumentException expected) {
137    }
138  }
139
140  public void testJoin() {
141    assertEquals("", Booleans.join(",", EMPTY));
142    assertEquals("false", Booleans.join(",", ARRAY_FALSE));
143    assertEquals("false,true", Booleans.join(",", false, true));
144    assertEquals("falsetruefalse",
145        Booleans.join("", false, true, false));
146  }
147
148  public void testLexicographicalComparator() {
149    List<boolean[]> ordered = Arrays.asList(
150        new boolean[] {},
151        new boolean[] {false},
152        new boolean[] {false, false},
153        new boolean[] {false, true},
154        new boolean[] {true},
155        new boolean[] {true, false},
156        new boolean[] {true, true},
157        new boolean[] {true, true, true});
158
159    Comparator<boolean[]> comparator = Booleans.lexicographicalComparator();
160    Helpers.testComparator(comparator, ordered);
161  }
162
163  @GwtIncompatible("SerializableTester")
164  public void testLexicographicalComparatorSerializable() {
165    Comparator<boolean[]> comparator = Booleans.lexicographicalComparator();
166    assertSame(comparator, SerializableTester.reserialize(comparator));
167  }
168
169  public void testToArray() {
170    // need explicit type parameter to avoid javac warning!?
171    List<Boolean> none = Arrays.<Boolean>asList();
172    assertTrue(Arrays.equals(EMPTY, Booleans.toArray(none)));
173
174    List<Boolean> one = Arrays.asList(false);
175    assertTrue(Arrays.equals(ARRAY_FALSE, Booleans.toArray(one)));
176
177    boolean[] array = {false, false, true};
178
179    List<Boolean> three = Arrays.asList(false, false, true);
180    assertTrue(Arrays.equals(array, Booleans.toArray(three)));
181
182    assertTrue(Arrays.equals(array, Booleans.toArray(Booleans.asList(array))));
183  }
184
185  public void testToArray_threadSafe() {
186    // Only for booleans, we lengthen VALUES
187    boolean[] VALUES = BooleansTest.VALUES;
188    VALUES = Booleans.concat(VALUES, VALUES);
189
190    for (int delta : new int[] { +1, 0, -1 }) {
191      for (int i = 0; i < VALUES.length; i++) {
192        List<Boolean> list = Booleans.asList(VALUES).subList(0, i);
193        Collection<Boolean> misleadingSize =
194            Helpers.misleadingSizeCollection(delta);
195        misleadingSize.addAll(list);
196        boolean[] arr = Booleans.toArray(misleadingSize);
197        assertEquals(i, arr.length);
198        for (int j = 0; j < i; j++) {
199          assertEquals(VALUES[j], arr[j]);
200        }
201      }
202    }
203  }
204
205  public void testToArray_withNull() {
206    List<Boolean> list = Arrays.asList(false, true, null);
207    try {
208      Booleans.toArray(list);
209      fail();
210    } catch (NullPointerException expected) {
211    }
212  }
213
214  public void testAsListIsEmpty() {
215    assertTrue(Booleans.asList(EMPTY).isEmpty());
216    assertFalse(Booleans.asList(ARRAY_FALSE).isEmpty());
217  }
218
219  public void testAsListSize() {
220    assertEquals(0, Booleans.asList(EMPTY).size());
221    assertEquals(1, Booleans.asList(ARRAY_FALSE).size());
222    assertEquals(2, Booleans.asList(ARRAY_FALSE_TRUE).size());
223  }
224
225  public void testAsListIndexOf() {
226    assertEquals(-1, Booleans.asList(EMPTY).indexOf("wrong type"));
227    assertEquals(-1, Booleans.asList(EMPTY).indexOf(true));
228    assertEquals(-1, Booleans.asList(ARRAY_FALSE).indexOf(true));
229    assertEquals(0, Booleans.asList(ARRAY_FALSE).indexOf(false));
230    assertEquals(1, Booleans.asList(ARRAY_FALSE_TRUE).indexOf(true));
231  }
232
233  public void testAsListLastIndexOf() {
234    assertEquals(-1, Booleans.asList(EMPTY).indexOf("wrong type"));
235    assertEquals(-1, Booleans.asList(EMPTY).indexOf(true));
236    assertEquals(-1, Booleans.asList(ARRAY_FALSE).lastIndexOf(true));
237    assertEquals(1, Booleans.asList(ARRAY_FALSE_TRUE).lastIndexOf(true));
238    assertEquals(1, Booleans.asList(ARRAY_FALSE_FALSE).lastIndexOf(false));
239  }
240
241  public void testAsListContains() {
242    assertFalse(Booleans.asList(EMPTY).contains("wrong type"));
243    assertFalse(Booleans.asList(EMPTY).contains(true));
244    assertFalse(Booleans.asList(ARRAY_FALSE).contains(true));
245    assertTrue(Booleans.asList(ARRAY_TRUE).contains(true));
246    assertTrue(Booleans.asList(ARRAY_FALSE_TRUE).contains(false));
247    assertTrue(Booleans.asList(ARRAY_FALSE_TRUE).contains(true));
248  }
249
250  public void testAsListEquals() {
251    assertEquals(Booleans.asList(EMPTY), Collections.emptyList());
252    assertEquals(Booleans.asList(ARRAY_FALSE), Booleans.asList(ARRAY_FALSE));
253    assertFalse(Booleans.asList(ARRAY_FALSE).equals(ARRAY_FALSE));
254    assertFalse(Booleans.asList(ARRAY_FALSE).equals(null));
255    assertFalse(Booleans.asList(ARRAY_FALSE).equals(Booleans.asList(ARRAY_FALSE_TRUE)));
256    assertFalse(Booleans.asList(ARRAY_FALSE_FALSE).equals(Booleans.asList(ARRAY_FALSE_TRUE)));
257    assertEquals(1, Booleans.asList(ARRAY_FALSE_TRUE).lastIndexOf(true));
258    List<Boolean> reference = Booleans.asList(ARRAY_FALSE);
259    assertEquals(Booleans.asList(ARRAY_FALSE), reference);
260    assertEquals(reference, reference);
261  }
262
263  public void testAsListHashcode() {
264    assertEquals(1, Booleans.asList(EMPTY).hashCode());
265    assertEquals(Booleans.asList(ARRAY_FALSE).hashCode(), Booleans.asList(ARRAY_FALSE).hashCode());
266    List<Boolean> reference = Booleans.asList(ARRAY_FALSE);
267    assertEquals(Booleans.asList(ARRAY_FALSE).hashCode(), reference.hashCode());
268  }
269
270  public void testAsListToString() {
271    assertEquals("[false]", Booleans.asList(ARRAY_FALSE).toString());
272    assertEquals("[false, true]", Booleans.asList(ARRAY_FALSE_TRUE).toString());
273  }
274
275  public void testAsListSet() {
276    List<Boolean> list = Booleans.asList(ARRAY_FALSE);
277    assertFalse(list.set(0, true));
278    assertTrue(list.set(0, false));
279    try {
280      list.set(0, null);
281      fail();
282    } catch (NullPointerException expected) {
283    }
284    try {
285      list.set(1, true);
286      fail();
287    } catch (IndexOutOfBoundsException expected) {
288    }
289  }
290
291  public void testCountTrue() {
292    assertEquals(0, Booleans.countTrue());
293    assertEquals(0, Booleans.countTrue(false));
294    assertEquals(1, Booleans.countTrue(true));
295    assertEquals(3, Booleans.countTrue(false, true, false, true, false, true));
296    assertEquals(1, Booleans.countTrue(false, false, true, false, false));
297  }
298
299  @GwtIncompatible("NullPointerTester")
300  public void testNulls() {
301    new NullPointerTester().testAllPublicStaticMethods(Booleans.class);
302  }
303}
304