Skip to content

Commit 8f1f21e

Browse files
patrickfavpatrickfav
committed
Refactor Util tests and add test for toIntArray()
1 parent ccb6d5c commit 8f1f21e

File tree

3 files changed

+159
-125
lines changed

3 files changed

+159
-125
lines changed

‎src/test/java/at/favre/lib/bytes/AUtilTest.java‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,7 @@
1+
package at.favre.lib.bytes;
2+
3+
abstract class AUtilTest {
4+
static final byte[] EMPTY = {};
5+
static final byte[] ARRAY1 = {(byte) 1};
6+
static final byte[] ARRAY234 = {(byte) 2, (byte) 3, (byte) 4};
7+
}

src/test/java/at/favre/lib/bytes/UtilTest.java renamed to src/test/java/at/favre/lib/bytes/UtilByteTest.java

Lines changed: 12 additions & 125 deletions
Original file line numberDiff line numberDiff line change
@@ -25,19 +25,12 @@
2525
import org.junit.Test;
2626

2727
import java.math.BigInteger;
28-
import java.nio.charset.Charset;
29-
import java.nio.charset.StandardCharsets;
3028
import java.util.Arrays;
31-
import java.util.List;
3229
import java.util.Random;
3330

34-
import static junit.framework.TestCase.assertTrue;
3531
import static org.junit.Assert.*;
3632

37-
public class UtilTest {
38-
private static final byte[] EMPTY = {};
39-
private static final byte[] ARRAY1 = {(byte) 1};
40-
private static final byte[] ARRAY234 = {(byte) 2, (byte) 3, (byte) 4};
33+
public class UtilByteTest extends AUtilTest {
4134

4235
@Test
4336
public void testIndexOf() {
@@ -111,78 +104,18 @@ private int lastIndexOf(byte[] empty, byte b) {
111104

112105
@Test
113106
public void testConcat() {
114-
assertTrue(Arrays.equals(EMPTY, Util.Byte.concat()));
115-
assertTrue(Arrays.equals(EMPTY, Util.Byte.concat(EMPTY)));
116-
assertTrue(Arrays.equals(EMPTY, Util.Byte.concat(EMPTY, EMPTY, EMPTY)));
117-
assertTrue(Arrays.equals(ARRAY1, Util.Byte.concat(ARRAY1)));
107+
assertArrayEquals(EMPTY, Util.Byte.concat());
108+
assertArrayEquals(EMPTY, Util.Byte.concat(EMPTY));
109+
assertArrayEquals(EMPTY, Util.Byte.concat(EMPTY, EMPTY, EMPTY));
110+
assertArrayEquals(ARRAY1, Util.Byte.concat(ARRAY1));
118111
assertNotSame(ARRAY1, Util.Byte.concat(ARRAY1));
119-
assertTrue(Arrays.equals(ARRAY1, Util.Byte.concat(EMPTY, ARRAY1, EMPTY)));
120-
assertTrue(Arrays.equals(
112+
assertArrayEquals(ARRAY1, Util.Byte.concat(EMPTY, ARRAY1, EMPTY));
113+
assertArrayEquals(
121114
new byte[]{(byte) 1, (byte) 1, (byte) 1},
122-
Util.Byte.concat(ARRAY1, ARRAY1, ARRAY1)));
123-
assertTrue(Arrays.equals(
115+
Util.Byte.concat(ARRAY1, ARRAY1, ARRAY1));
116+
assertArrayEquals(
124117
new byte[]{(byte) 1, (byte) 2, (byte) 3, (byte) 4},
125-
Util.Byte.concat(ARRAY1, ARRAY234)));
126-
}
127-
128-
@Test
129-
public void testToArray() {
130-
// need explicit type parameter to avoid javac warning!?
131-
List<Byte> none = Arrays.asList();
132-
assertTrue(Arrays.equals(EMPTY, Util.Converter.toArray(none)));
133-
134-
List<Byte> one = Arrays.asList((byte) 1);
135-
assertTrue(Arrays.equals(ARRAY1, Util.Converter.toArray(one)));
136-
137-
byte[] array = {(byte) 0, (byte) 1, (byte) 0x55};
138-
139-
List<Byte> three = Arrays.asList((byte) 0, (byte) 1, (byte) 0x55);
140-
assertTrue(Arrays.equals(array, Util.Converter.toArray(three)));
141-
142-
assertTrue(Arrays.equals(array, Util.Converter.toArray(Util.Converter.toList(array))));
143-
}
144-
145-
@Test
146-
public void testToArray_withNull() {
147-
List<Byte> list = Arrays.asList((byte) 0, (byte) 1, null);
148-
try {
149-
Util.Converter.toArray(list);
150-
fail();
151-
} catch (NullPointerException expected) {
152-
}
153-
}
154-
155-
@Test
156-
public void testToArray_withConversion() {
157-
byte[] array = {(byte) 0, (byte) 1, (byte) 2};
158-
159-
List<Byte> bytes = Arrays.asList((byte) 0, (byte) 1, (byte) 2);
160-
assertTrue(Arrays.equals(array, Util.Converter.toArray(bytes)));
161-
}
162-
163-
@Test
164-
public void testAsList_toArray_roundTrip() {
165-
byte[] array = {(byte) 0, (byte) 1, (byte) 2};
166-
List<Byte> list = Util.Converter.toList(array);
167-
byte[] newArray = Util.Converter.toArray(list);
168-
169-
// Make sure it returned a copy
170-
list.set(0, (byte) 4);
171-
assertTrue(Arrays.equals(
172-
new byte[]{(byte) 0, (byte) 1, (byte) 2}, newArray));
173-
newArray[1] = (byte) 5;
174-
assertEquals((byte) 1, (byte) list.get(1));
175-
}
176-
177-
@Test
178-
// This test stems from a real bug found by andrewk
179-
public void testAsList_subList_toArray_roundTrip() {
180-
byte[] array = {(byte) 0, (byte) 1, (byte) 2, (byte) 3};
181-
List<Byte> list = Util.Converter.toList(array);
182-
assertTrue(Arrays.equals(new byte[]{(byte) 1, (byte) 2},
183-
Util.Converter.toArray(list.subList(1, 3))));
184-
assertTrue(Arrays.equals(new byte[]{},
185-
Util.Converter.toArray(list.subList(2, 2))));
118+
Util.Byte.concat(ARRAY1, ARRAY234));
186119
}
187120

188121
@Test(expected = IllegalStateException.class)
@@ -217,13 +150,13 @@ public void testReverseIndexed() {
217150
private static void testReverse(byte[] input, byte[] expectedOutput) {
218151
input = Arrays.copyOf(input, input.length);
219152
Util.Byte.reverse(input, 0, input.length);
220-
assertTrue(Arrays.equals(expectedOutput, input));
153+
assertArrayEquals(expectedOutput, input);
221154
}
222155

223156
private static void testReverse(byte[] input, int fromIndex, int toIndex, byte[] expectedOutput) {
224157
input = Arrays.copyOf(input, input.length);
225158
Util.Byte.reverse(input, fromIndex, toIndex);
226-
assertTrue(Arrays.equals(expectedOutput, input));
159+
assertArrayEquals(expectedOutput, input);
227160
}
228161

229162
@Test
@@ -301,50 +234,4 @@ public void testRightShiftAgainstRefImpl() {
301234
}
302235
}
303236
}
304-
305-
@Test
306-
public void testCharToByteArray() {
307-
Charset[] charsets = new Charset[]{StandardCharsets.UTF_8, StandardCharsets.US_ASCII, StandardCharsets.UTF_16};
308-
for (Charset charset : charsets) {
309-
checkCharArrayToByteArray("".toCharArray(), charset);
310-
checkCharArrayToByteArray("A".toCharArray(), charset);
311-
checkCharArrayToByteArray("12".toCharArray(), charset);
312-
checkCharArrayToByteArray("XYZ".toCharArray(), charset);
313-
checkCharArrayToByteArray("abcdefg".toCharArray(), charset);
314-
checkCharArrayToByteArray("71oh872gdl2dhp81g".toCharArray(), charset);
315-
316-
}
317-
318-
checkCharArrayToByteArray("யe2ாமறிந்தиют убSîne klâwenasd1".toCharArray(), StandardCharsets.UTF_8);
319-
}
320-
321-
private void checkCharArrayToByteArray(char[] subject, Charset charset) {
322-
for (int lenI = 1; lenI < subject.length + 1; lenI++) {
323-
for (int offsetI = 0; offsetI < subject.length; offsetI++) {
324-
if (offsetI + lenI > subject.length) break;
325-
byte[] bytes = Util.Converter.charToByteArray(subject, charset, offsetI, lenI);
326-
assertEquals(Bytes.wrap(bytes), Bytes.wrap(new String(subject).substring(offsetI, offsetI + lenI).getBytes(charset)));
327-
}
328-
}
329-
compareArrayToByteArrayWithoutOffset(subject, charset);
330-
}
331-
332-
private void compareArrayToByteArrayWithoutOffset(char[] subject, Charset charset) {
333-
assertArrayEquals(Util.Converter.charToByteArray(subject, charset, 0, subject.length), new String(subject).getBytes(charset));
334-
}
335-
336-
@Test(expected = IllegalArgumentException.class)
337-
public void testCharToByteArrayIllegalOffset() {
338-
Util.Converter.charToByteArray("abcdef".toCharArray(), StandardCharsets.UTF_8, -1, 1);
339-
}
340-
341-
@Test(expected = IllegalArgumentException.class)
342-
public void testCharToByteArrayIllegalLength() {
343-
Util.Converter.charToByteArray("abcdef".toCharArray(), StandardCharsets.UTF_8, 0, -1);
344-
}
345-
346-
@Test(expected = IllegalArgumentException.class)
347-
public void testCharToByteArrayIllegalOffsetPlusLength() {
348-
Util.Converter.charToByteArray("abcdef".toCharArray(), StandardCharsets.UTF_8, 4, 3);
349-
}
350237
}

‎src/test/java/at/favre/lib/bytes/UtilConverterTest.java‎

Lines changed: 140 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,140 @@
1+
package at.favre.lib.bytes;
2+
3+
import org.junit.Test;
4+
5+
import java.nio.ByteOrder;
6+
import java.nio.charset.Charset;
7+
import java.nio.charset.StandardCharsets;
8+
import java.util.Arrays;
9+
import java.util.Collections;
10+
import java.util.List;
11+
12+
import static org.junit.Assert.*;
13+
14+
public class UtilConverterTest extends AUtilTest {
15+
16+
@Test
17+
public void testToArray() {
18+
List<Byte> none = Collections.emptyList();
19+
assertArrayEquals(EMPTY, Util.Converter.toArray(none));
20+
21+
List<Byte> one = Collections.singletonList((byte) 1);
22+
assertArrayEquals(ARRAY1, Util.Converter.toArray(one));
23+
24+
byte[] array = {(byte) 0, (byte) 1, (byte) 0x55};
25+
26+
List<Byte> three = Arrays.asList((byte) 0, (byte) 1, (byte) 0x55);
27+
assertArrayEquals(array, Util.Converter.toArray(three));
28+
29+
assertArrayEquals(array, Util.Converter.toArray(Util.Converter.toList(array)));
30+
}
31+
32+
@Test
33+
public void testToArray_withNull() {
34+
List<Byte> list = Arrays.asList((byte) 0, (byte) 1, null);
35+
try {
36+
Util.Converter.toArray(list);
37+
fail();
38+
} catch (NullPointerException expected) {
39+
}
40+
}
41+
42+
@Test
43+
public void testToArray_withConversion() {
44+
byte[] array = {(byte) 0, (byte) 1, (byte) 2};
45+
46+
List<Byte> bytes = Arrays.asList((byte) 0, (byte) 1, (byte) 2);
47+
assertArrayEquals(array, Util.Converter.toArray(bytes));
48+
}
49+
50+
@Test
51+
public void testAsList_toArray_roundTrip() {
52+
byte[] array = {(byte) 0, (byte) 1, (byte) 2};
53+
List<Byte> list = Util.Converter.toList(array);
54+
byte[] newArray = Util.Converter.toArray(list);
55+
56+
// Make sure it returned a copy
57+
list.set(0, (byte) 4);
58+
assertArrayEquals(
59+
new byte[]{(byte) 0, (byte) 1, (byte) 2}, newArray);
60+
newArray[1] = (byte) 5;
61+
assertEquals((byte) 1, (byte) list.get(1));
62+
}
63+
64+
@Test
65+
// This test stems from a real bug found by andrewk
66+
public void testAsList_subList_toArray_roundTrip() {
67+
byte[] array = {(byte) 0, (byte) 1, (byte) 2, (byte) 3};
68+
List<Byte> list = Util.Converter.toList(array);
69+
assertArrayEquals(new byte[]{(byte) 1, (byte) 2},
70+
Util.Converter.toArray(list.subList(1, 3)));
71+
assertArrayEquals(new byte[]{},
72+
Util.Converter.toArray(list.subList(2, 2)));
73+
}
74+
75+
@Test
76+
public void testCharToByteArray() {
77+
Charset[] charsets = new Charset[]{StandardCharsets.UTF_8, StandardCharsets.US_ASCII, StandardCharsets.UTF_16};
78+
for (Charset charset : charsets) {
79+
checkCharArrayToByteArray("".toCharArray(), charset);
80+
checkCharArrayToByteArray("A".toCharArray(), charset);
81+
checkCharArrayToByteArray("12".toCharArray(), charset);
82+
checkCharArrayToByteArray("XYZ".toCharArray(), charset);
83+
checkCharArrayToByteArray("abcdefg".toCharArray(), charset);
84+
checkCharArrayToByteArray("71oh872gdl2dhp81g".toCharArray(), charset);
85+
86+
}
87+
88+
checkCharArrayToByteArray("யe2ாமறிந்தиют убSîne klâwenasd1".toCharArray(), StandardCharsets.UTF_8);
89+
}
90+
91+
private void checkCharArrayToByteArray(char[] subject, Charset charset) {
92+
for (int lenI = 1; lenI < subject.length + 1; lenI++) {
93+
for (int offsetI = 0; offsetI < subject.length; offsetI++) {
94+
if (offsetI + lenI > subject.length) break;
95+
byte[] bytes = Util.Converter.charToByteArray(subject, charset, offsetI, lenI);
96+
assertEquals(Bytes.wrap(bytes), Bytes.wrap(new String(subject).substring(offsetI, offsetI + lenI).getBytes(charset)));
97+
}
98+
}
99+
compareArrayToByteArrayWithoutOffset(subject, charset);
100+
}
101+
102+
private void compareArrayToByteArrayWithoutOffset(char[] subject, Charset charset) {
103+
assertArrayEquals(Util.Converter.charToByteArray(subject, charset, 0, subject.length), new String(subject).getBytes(charset));
104+
}
105+
106+
@Test(expected = IllegalArgumentException.class)
107+
public void testCharToByteArrayIllegalOffset() {
108+
Util.Converter.charToByteArray("abcdef".toCharArray(), StandardCharsets.UTF_8, -1, 1);
109+
}
110+
111+
@Test(expected = IllegalArgumentException.class)
112+
public void testCharToByteArrayIllegalLength() {
113+
Util.Converter.charToByteArray("abcdef".toCharArray(), StandardCharsets.UTF_8, 0, -1);
114+
}
115+
116+
@Test(expected = IllegalArgumentException.class)
117+
public void testCharToByteArrayIllegalOffsetPlusLength() {
118+
Util.Converter.charToByteArray("abcdef".toCharArray(), StandardCharsets.UTF_8, 4, 3);
119+
}
120+
121+
@Test
122+
public void testToIntArray() {
123+
assertArrayEquals(new int[]{1}, Util.Converter.toIntArray(new byte[]{0, 0, 0, 1}, ByteOrder.BIG_ENDIAN));
124+
assertArrayEquals(new int[]{257}, Util.Converter.toIntArray(new byte[]{0, 0, 1, 1}, ByteOrder.BIG_ENDIAN));
125+
126+
assertArrayEquals(new int[]{1}, Util.Converter.toIntArray(new byte[]{1, 0, 0, 0}, ByteOrder.LITTLE_ENDIAN));
127+
assertArrayEquals(new int[]{257}, Util.Converter.toIntArray(new byte[]{1, 1, 0, 0}, ByteOrder.LITTLE_ENDIAN));
128+
129+
assertArrayEquals(new int[]{16_843_009}, Util.Converter.toIntArray(new byte[]{1, 1, 1, 1}, ByteOrder.BIG_ENDIAN));
130+
assertArrayEquals(new int[]{571_211_845}, Util.Converter.toIntArray(new byte[]{34, 12, 0, 69}, ByteOrder.BIG_ENDIAN));
131+
assertArrayEquals(new int[]{1_290_429_439}, Util.Converter.toIntArray(new byte[]{76, (byte) 234, 99, (byte) 255}, ByteOrder.BIG_ENDIAN));
132+
assertArrayEquals(new int[]{257, 65_793, 1}, Util.Converter.toIntArray(new byte[]{0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1}, ByteOrder.BIG_ENDIAN));
133+
134+
assertArrayEquals(new int[]{1_290_429_439}, Util.Converter.toIntArray(new byte[]{(byte) 255, 99, (byte) 234, 76}, ByteOrder.LITTLE_ENDIAN));
135+
assertArrayEquals(new int[]{257, 65_793, 1}, Util.Converter.toIntArray(new byte[]{1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0}, ByteOrder.LITTLE_ENDIAN));
136+
137+
assertArrayEquals(new int[0], Util.Converter.toIntArray(new byte[0], ByteOrder.LITTLE_ENDIAN));
138+
assertArrayEquals(new int[0], Util.Converter.toIntArray(new byte[0], ByteOrder.BIG_ENDIAN));
139+
}
140+
}

0 commit comments

Comments
 (0)