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.collect.testing.Helpers;
20 import com.google.common.testing.NullPointerTester;
21 import com.google.common.testing.SerializableTester;
22 
23 import junit.framework.TestCase;
24 
25 import java.util.Arrays;
26 import java.util.Comparator;
27 import java.util.List;
28 
29 /**
30  * Unit test for {@link UnsignedBytes}.
31  *
32  * @author Kevin Bourrillion
33  * @author Louis Wasserman
34  */
35 public class UnsignedBytesTest extends TestCase {
36   private static final byte LEAST = 0;
37   private static final byte GREATEST = (byte) 255;
38 
39   // Only in this class, VALUES must be strictly ascending
40   private static final byte[] VALUES =
41       {LEAST, 127, (byte) 128, (byte) 129, GREATEST};
42 
testToInt()43   public void testToInt() {
44     assertEquals(0, UnsignedBytes.toInt((byte) 0));
45     assertEquals(1, UnsignedBytes.toInt((byte) 1));
46     assertEquals(127, UnsignedBytes.toInt((byte) 127));
47     assertEquals(128, UnsignedBytes.toInt((byte) -128));
48     assertEquals(129, UnsignedBytes.toInt((byte) -127));
49     assertEquals(255, UnsignedBytes.toInt((byte) -1));
50   }
51 
testCheckedCast()52   public void testCheckedCast() {
53     for (byte value : VALUES) {
54       assertEquals(value,
55           UnsignedBytes.checkedCast(UnsignedBytes.toInt(value)));
56     }
57     assertCastFails(256L);
58     assertCastFails(-1L);
59     assertCastFails(Long.MAX_VALUE);
60     assertCastFails(Long.MIN_VALUE);
61   }
62 
testSaturatedCast()63   public void testSaturatedCast() {
64     for (byte value : VALUES) {
65       assertEquals(value,
66           UnsignedBytes.saturatedCast(UnsignedBytes.toInt(value)));
67     }
68     assertEquals(GREATEST, UnsignedBytes.saturatedCast(256L));
69     assertEquals(LEAST, UnsignedBytes.saturatedCast(-1L));
70     assertEquals(GREATEST, UnsignedBytes.saturatedCast(Long.MAX_VALUE));
71     assertEquals(LEAST, UnsignedBytes.saturatedCast(Long.MIN_VALUE));
72   }
73 
assertCastFails(long value)74   private static void assertCastFails(long value) {
75     try {
76       UnsignedBytes.checkedCast(value);
77       fail("Cast to byte should have failed: " + value);
78     } catch (IllegalArgumentException ex) {
79       assertTrue(value + " not found in exception text: " + ex.getMessage(),
80           ex.getMessage().contains(String.valueOf(value)));
81     }
82   }
83 
testCompare()84   public void testCompare() {
85     // This is the only ordering for primitives that does not have a
86     // corresponding Comparable wrapper in java.lang.
87     for (int i = 0; i < VALUES.length; i++) {
88       for (int j = 0; j < VALUES.length; j++) {
89         byte x = VALUES[i];
90         byte y = VALUES[j];
91         // note: spec requires only that the sign is the same
92         assertEquals(x + ", " + y,
93                      Math.signum(UnsignedBytes.compare(x, y)),
94                      Math.signum(Ints.compare(i, j)));
95       }
96     }
97   }
98 
testMax_noArgs()99   public void testMax_noArgs() {
100     try {
101       UnsignedBytes.max();
102       fail();
103     } catch (IllegalArgumentException expected) {
104     }
105   }
106 
testMax()107   public void testMax() {
108     assertEquals(LEAST, UnsignedBytes.max(LEAST));
109     assertEquals(GREATEST, UnsignedBytes.max(GREATEST));
110     assertEquals((byte) 255, UnsignedBytes.max(
111         (byte) 0, (byte) -128, (byte) -1, (byte) 127, (byte) 1));
112   }
113 
testMin_noArgs()114   public void testMin_noArgs() {
115     try {
116       UnsignedBytes.min();
117       fail();
118     } catch (IllegalArgumentException expected) {
119     }
120   }
121 
testMin()122   public void testMin() {
123     assertEquals(LEAST, UnsignedBytes.min(LEAST));
124     assertEquals(GREATEST, UnsignedBytes.min(GREATEST));
125     assertEquals((byte) 0, UnsignedBytes.min(
126         (byte) 0, (byte) -128, (byte) -1, (byte) 127, (byte) 1));
127     assertEquals((byte) 0, UnsignedBytes.min(
128         (byte) -1, (byte) 127, (byte) 1, (byte) -128, (byte) 0));
129   }
130 
assertParseFails(String value)131   private static void assertParseFails(String value) {
132     try {
133       UnsignedBytes.parseUnsignedByte(value);
134       fail();
135     } catch (NumberFormatException expected) {
136     }
137   }
138 
testParseUnsignedByte()139   public void testParseUnsignedByte() {
140     // We can easily afford to test this exhaustively.
141     for (int i = 0; i <= 0xff; i++) {
142       assertEquals((byte) i, UnsignedBytes.parseUnsignedByte(Integer.toString(i)));
143     }
144     assertParseFails("1000");
145     assertParseFails("-1");
146     assertParseFails("-128");
147     assertParseFails("256");
148   }
149 
testMaxValue()150   public void testMaxValue() {
151     assertTrue(UnsignedBytes
152         .compare(UnsignedBytes.MAX_VALUE, (byte) (UnsignedBytes.MAX_VALUE + 1)) > 0);
153   }
154 
assertParseFails(String value, int radix)155   private static void assertParseFails(String value, int radix) {
156     try {
157       UnsignedBytes.parseUnsignedByte(value, radix);
158       fail();
159     } catch (NumberFormatException expected) {
160     }
161   }
162 
testParseUnsignedByteWithRadix()163   public void testParseUnsignedByteWithRadix() throws NumberFormatException {
164     // We can easily afford to test this exhaustively.
165     for (int radix = Character.MIN_RADIX; radix <= Character.MAX_RADIX; radix++) {
166       for (int i = 0; i <= 0xff; i++) {
167         assertEquals((byte) i, UnsignedBytes.parseUnsignedByte(Integer.toString(i, radix), radix));
168       }
169       assertParseFails(Integer.toString(1000, radix), radix);
170       assertParseFails(Integer.toString(-1, radix), radix);
171       assertParseFails(Integer.toString(-128, radix), radix);
172       assertParseFails(Integer.toString(256, radix), radix);
173     }
174   }
175 
testParseUnsignedByteThrowsExceptionForInvalidRadix()176   public void testParseUnsignedByteThrowsExceptionForInvalidRadix() {
177     // Valid radix values are Character.MIN_RADIX to Character.MAX_RADIX,
178     // inclusive.
179     try {
180       UnsignedBytes.parseUnsignedByte("0", Character.MIN_RADIX - 1);
181       fail();
182     } catch (NumberFormatException nfe) {
183       // expected
184     }
185 
186     try {
187       UnsignedBytes.parseUnsignedByte("0", Character.MAX_RADIX + 1);
188       fail();
189     } catch (NumberFormatException nfe) {
190       // expected
191     }
192 
193     // The radix is used as an array index, so try a negative value.
194     try {
195       UnsignedBytes.parseUnsignedByte("0", -1);
196       fail();
197     } catch (NumberFormatException nfe) {
198       // expected
199     }
200   }
201 
testToString()202   public void testToString() {
203     // We can easily afford to test this exhaustively.
204     for (int i = 0; i <= 0xff; i++) {
205       assertEquals(Integer.toString(i), UnsignedBytes.toString((byte) i));
206     }
207   }
208 
testToStringWithRadix()209   public void testToStringWithRadix() {
210     // We can easily afford to test this exhaustively.
211     for (int radix = Character.MIN_RADIX; radix <= Character.MAX_RADIX; radix++) {
212       for (int i = 0; i <= 0xff; i++) {
213         assertEquals(Integer.toString(i, radix), UnsignedBytes.toString((byte) i, radix));
214       }
215     }
216   }
217 
testJoin()218   public void testJoin() {
219     assertEquals("", UnsignedBytes.join(",", new byte[] {}));
220     assertEquals("1", UnsignedBytes.join(",", new byte[] {(byte) 1}));
221     assertEquals("1,2", UnsignedBytes.join(",", (byte) 1, (byte) 2));
222     assertEquals("123", UnsignedBytes.join("", (byte) 1, (byte) 2, (byte) 3));
223     assertEquals("128,255", UnsignedBytes.join(",", (byte) 128, (byte) -1));
224   }
225 
testLexicographicalComparatorDefaultChoice()226   public void testLexicographicalComparatorDefaultChoice() {
227     Comparator<byte[]> defaultComparator =
228         UnsignedBytes.lexicographicalComparator();
229     Comparator<byte[]> pureJavaComparator =
230         UnsignedBytes.LexicographicalComparatorHolder.PureJavaComparator.INSTANCE;
231     assertSame(defaultComparator, pureJavaComparator);
232   }
233 
testLexicographicalComparator()234   public void testLexicographicalComparator() {
235     List<byte[]> ordered = Arrays.asList(
236         new byte[] {},
237         new byte[] {LEAST},
238         new byte[] {LEAST, LEAST},
239         new byte[] {LEAST, (byte) 1},
240         new byte[] {(byte) 1},
241         new byte[] {(byte) 1, LEAST},
242         new byte[] {GREATEST, GREATEST - (byte) 1},
243         new byte[] {GREATEST, GREATEST},
244         new byte[] {GREATEST, GREATEST, GREATEST});
245 
246     // The Unsafe implementation if it's available. Otherwise, the Java implementation.
247     Comparator<byte[]> comparator = UnsignedBytes.lexicographicalComparator();
248     Helpers.testComparator(comparator, ordered);
249     assertSame(comparator, SerializableTester.reserialize(comparator));
250 
251     // The Java implementation.
252     Comparator<byte[]> javaImpl = UnsignedBytes.lexicographicalComparatorJavaImpl();
253     Helpers.testComparator(javaImpl, ordered);
254     assertSame(javaImpl, SerializableTester.reserialize(javaImpl));
255   }
256 
257   @SuppressWarnings("unchecked")
testLexicographicalComparatorLongInputs()258   public void testLexicographicalComparatorLongInputs() {
259     for (Comparator<byte[]> comparator : Arrays.asList(
260         UnsignedBytes.lexicographicalComparator(),
261         UnsignedBytes.lexicographicalComparatorJavaImpl())) {
262       for (int i = 0; i < 32; i++) {
263         byte[] left = new byte[32];
264         byte[] right = new byte[32];
265 
266         assertTrue(comparator.compare(left, right) == 0);
267         left[i] = 1;
268         assertTrue(comparator.compare(left, right) > 0);
269         assertTrue(comparator.compare(right, left) < 0);
270       }
271     }
272   }
273 
274   public void testNulls() {
275     new NullPointerTester().testAllPublicStaticMethods(UnsignedBytes.class);
276   }
277 }
278