Skip to content

Commit 0b672eb

Browse files
adamretteradamretter
committed
Imporve array equality assertions in tests
1 parent 196f32e commit 0b672eb

4 files changed

Lines changed: 50 additions & 52 deletions

File tree

‎src/test/java/org/apache/commons/codec/binary/Base32InputStreamTest.java‎

Lines changed: 12 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -17,21 +17,20 @@
1717

1818
package org.apache.commons.codec.binary;
1919

20-
import static org.junit.Assert.assertArrayEquals;
21-
import static org.junit.Assert.assertEquals;
22-
import static org.junit.Assert.assertFalse;
23-
import static org.junit.Assert.assertTrue;
24-
import static org.junit.Assert.fail;
25-
2620
import java.io.ByteArrayInputStream;
2721
import java.io.ByteArrayOutputStream;
2822
import java.io.IOException;
2923
import java.io.InputStream;
30-
import java.util.Arrays;
3124

3225
import org.apache.commons.codec.CodecPolicy;
3326
import org.junit.Test;
3427

28+
import static org.junit.Assert.assertArrayEquals;
29+
import static org.junit.Assert.assertEquals;
30+
import static org.junit.Assert.assertFalse;
31+
import static org.junit.Assert.assertTrue;
32+
import static org.junit.Assert.fail;
33+
3534
public class Base32InputStreamTest {
3635

3736
private static final String ENCODED_FOO = "MZXW6===";
@@ -291,15 +290,15 @@ private void testByChunk(final byte[] encoded, final byte[] decoded, final int c
291290

292291
assertEquals("EOF", -1, in.read());
293292
assertEquals("Still EOF", -1, in.read());
294-
assertTrue("Streaming base32 encode", Arrays.equals(output, encoded));
293+
assertArrayEquals("Streaming base32 encode", encoded, output);
295294

296295
// Now let's try decode.
297296
in = new Base32InputStream(new ByteArrayInputStream(encoded));
298297
output = BaseNTestData.streamToBytes(in);
299298

300299
assertEquals("EOF", -1, in.read());
301300
assertEquals("Still EOF", -1, in.read());
302-
assertTrue("Streaming base32 decode", Arrays.equals(output, decoded));
301+
assertArrayEquals("Streaming base32 decode", decoded, output);
303302

304303
// I always wanted to do this! (wrap encoder with decoder etc etc).
305304
in = new ByteArrayInputStream(decoded);
@@ -311,7 +310,7 @@ private void testByChunk(final byte[] encoded, final byte[] decoded, final int c
311310

312311
assertEquals("EOF", -1, in.read());
313312
assertEquals("Still EOF", -1, in.read());
314-
assertTrue("Streaming base32 wrap-wrap-wrap!", Arrays.equals(output, decoded));
313+
assertArrayEquals("Streaming base32 wrap-wrap-wrap!", decoded, output);
315314
in.close();
316315
}
317316

@@ -345,7 +344,7 @@ private void testByteByByte(final byte[] encoded, final byte[] decoded, final in
345344

346345
assertEquals("EOF", -1, in.read());
347346
assertEquals("Still EOF", -1, in.read());
348-
assertTrue("Streaming base32 encode", Arrays.equals(output, encoded));
347+
assertArrayEquals("Streaming base32 encode", encoded, output);
349348

350349
in.close();
351350

@@ -358,7 +357,7 @@ private void testByteByByte(final byte[] encoded, final byte[] decoded, final in
358357

359358
assertEquals("EOF", -1, in.read());
360359
assertEquals("Still EOF", -1, in.read());
361-
assertTrue("Streaming base32 decode", Arrays.equals(output, decoded));
360+
assertArrayEquals("Streaming base32 decode", decoded, output);
362361

363362
in.close();
364363

@@ -375,7 +374,7 @@ private void testByteByByte(final byte[] encoded, final byte[] decoded, final in
375374

376375
assertEquals("EOF", -1, in.read());
377376
assertEquals("Still EOF", -1, in.read());
378-
assertTrue("Streaming base32 wrap-wrap-wrap!", Arrays.equals(output, decoded));
377+
assertArrayEquals("Streaming base32 wrap-wrap-wrap!", decoded, output);
379378
}
380379

381380
/**

‎src/test/java/org/apache/commons/codec/binary/Base32OutputStreamTest.java‎

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -17,17 +17,17 @@
1717

1818
package org.apache.commons.codec.binary;
1919

20-
import static org.junit.Assert.assertFalse;
21-
import static org.junit.Assert.assertTrue;
22-
import static org.junit.Assert.fail;
23-
2420
import java.io.ByteArrayOutputStream;
2521
import java.io.OutputStream;
26-
import java.util.Arrays;
2722

2823
import org.apache.commons.codec.CodecPolicy;
2924
import org.junit.Test;
3025

26+
import static org.junit.Assert.assertArrayEquals;
27+
import static org.junit.Assert.assertFalse;
28+
import static org.junit.Assert.assertTrue;
29+
import static org.junit.Assert.fail;
30+
3131
public class Base32OutputStreamTest {
3232

3333
private final static byte[] CR_LF = {(byte) '\r', (byte) '\n'};
@@ -185,15 +185,15 @@ private void testByChunk(final byte[] encoded, final byte[] decoded, final int c
185185
out.write(decoded);
186186
out.close();
187187
byte[] output = byteOut.toByteArray();
188-
assertTrue("Streaming chunked Base32 encode", Arrays.equals(output, encoded));
188+
assertArrayEquals("Streaming chunked Base32 encode", encoded, output);
189189

190190
// Now let's try decode.
191191
byteOut = new ByteArrayOutputStream();
192192
out = new Base32OutputStream(byteOut, false);
193193
out.write(encoded);
194194
out.close();
195195
output = byteOut.toByteArray();
196-
assertTrue("Streaming chunked Base32 decode", Arrays.equals(output, decoded));
196+
assertArrayEquals("Streaming chunked Base32 decode", decoded, output);
197197

198198
// I always wanted to do this! (wrap encoder with decoder etc etc).
199199
byteOut = new ByteArrayOutputStream();
@@ -206,7 +206,7 @@ private void testByChunk(final byte[] encoded, final byte[] decoded, final int c
206206
out.close();
207207
output = byteOut.toByteArray();
208208

209-
assertTrue("Streaming chunked Base32 wrap-wrap-wrap!", Arrays.equals(output, decoded));
209+
assertArrayEquals("Streaming chunked Base32 wrap-wrap-wrap!", decoded, output);
210210
}
211211

212212
/**
@@ -237,7 +237,7 @@ private void testByteByByte(final byte[] encoded, final byte[] decoded, final in
237237
}
238238
out.close();
239239
byte[] output = byteOut.toByteArray();
240-
assertTrue("Streaming byte-by-byte Base32 encode", Arrays.equals(output, encoded));
240+
assertArrayEquals("Streaming byte-by-byte Base32 encode", encoded, output);
241241

242242
// Now let's try decode.
243243
byteOut = new ByteArrayOutputStream();
@@ -247,7 +247,7 @@ private void testByteByByte(final byte[] encoded, final byte[] decoded, final in
247247
}
248248
out.close();
249249
output = byteOut.toByteArray();
250-
assertTrue("Streaming byte-by-byte Base32 decode", Arrays.equals(output, decoded));
250+
assertArrayEquals("Streaming byte-by-byte Base32 decode", decoded, output);
251251

252252
// Now let's try decode with tonnes of flushes.
253253
byteOut = new ByteArrayOutputStream();
@@ -258,7 +258,7 @@ private void testByteByByte(final byte[] encoded, final byte[] decoded, final in
258258
}
259259
out.close();
260260
output = byteOut.toByteArray();
261-
assertTrue("Streaming byte-by-byte flush() Base32 decode", Arrays.equals(output, decoded));
261+
assertArrayEquals("Streaming byte-by-byte flush() Base32 decode", decoded, output);
262262

263263
// I always wanted to do this! (wrap encoder with decoder etc etc).
264264
byteOut = new ByteArrayOutputStream();
@@ -273,7 +273,7 @@ private void testByteByByte(final byte[] encoded, final byte[] decoded, final in
273273
out.close();
274274
output = byteOut.toByteArray();
275275

276-
assertTrue("Streaming byte-by-byte Base32 wrap-wrap-wrap!", Arrays.equals(output, decoded));
276+
assertArrayEquals("Streaming byte-by-byte Base32 wrap-wrap-wrap!", decoded, output);
277277
}
278278

279279
/**

‎src/test/java/org/apache/commons/codec/binary/Base64InputStreamTest.java‎

Lines changed: 13 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -17,24 +17,23 @@
1717

1818
package org.apache.commons.codec.binary;
1919

20-
import static org.junit.Assert.assertArrayEquals;
21-
import static org.junit.Assert.assertEquals;
22-
import static org.junit.Assert.assertFalse;
23-
import static org.junit.Assert.assertNotNull;
24-
import static org.junit.Assert.assertTrue;
25-
import static org.junit.Assert.fail;
26-
2720
import java.io.BufferedReader;
2821
import java.io.ByteArrayInputStream;
2922
import java.io.ByteArrayOutputStream;
3023
import java.io.IOException;
3124
import java.io.InputStream;
3225
import java.io.InputStreamReader;
33-
import java.util.Arrays;
3426

3527
import org.apache.commons.codec.CodecPolicy;
3628
import org.junit.Test;
3729

30+
import static org.junit.Assert.assertArrayEquals;
31+
import static org.junit.Assert.assertEquals;
32+
import static org.junit.Assert.assertFalse;
33+
import static org.junit.Assert.assertNotNull;
34+
import static org.junit.Assert.assertTrue;
35+
import static org.junit.Assert.fail;
36+
3837
/**
3938
* @since 1.4
4039
*/
@@ -304,7 +303,7 @@ private void testByChunk(final byte[] encoded, final byte[] decoded, final int c
304303

305304
assertEquals("EOF", -1, in.read());
306305
assertEquals("Still EOF", -1, in.read());
307-
assertTrue("Streaming base64 encode", Arrays.equals(output, encoded));
306+
assertArrayEquals("Streaming base64 encode", encoded, output);
308307

309308
in.close();
310309

@@ -314,7 +313,7 @@ private void testByChunk(final byte[] encoded, final byte[] decoded, final int c
314313

315314
assertEquals("EOF", -1, in.read());
316315
assertEquals("Still EOF", -1, in.read());
317-
assertTrue("Streaming base64 decode", Arrays.equals(output, decoded));
316+
assertArrayEquals("Streaming base64 decode", decoded, output);
318317

319318
// I always wanted to do this! (wrap encoder with decoder etc etc).
320319
in = new ByteArrayInputStream(decoded);
@@ -326,7 +325,7 @@ private void testByChunk(final byte[] encoded, final byte[] decoded, final int c
326325

327326
assertEquals("EOF", -1, in.read());
328327
assertEquals("Still EOF", -1, in.read());
329-
assertTrue("Streaming base64 wrap-wrap-wrap!", Arrays.equals(output, decoded));
328+
assertArrayEquals("Streaming base64 wrap-wrap-wrap!", decoded, output);
330329
in.close();
331330
}
332331

@@ -360,7 +359,7 @@ private void testByteByByte(final byte[] encoded, final byte[] decoded, final in
360359

361360
assertEquals("EOF", -1, in.read());
362361
assertEquals("Still EOF", -1, in.read());
363-
assertTrue("Streaming base64 encode", Arrays.equals(output, encoded));
362+
assertArrayEquals("Streaming base64 encode", encoded, output);
364363

365364
in.close();
366365
// Now let's try decode.
@@ -372,7 +371,7 @@ private void testByteByByte(final byte[] encoded, final byte[] decoded, final in
372371

373372
assertEquals("EOF", -1, in.read());
374373
assertEquals("Still EOF", -1, in.read());
375-
assertTrue("Streaming base64 decode", Arrays.equals(output, decoded));
374+
assertArrayEquals("Streaming base64 decode", decoded, output);
376375

377376
in.close();
378377

@@ -389,7 +388,7 @@ private void testByteByByte(final byte[] encoded, final byte[] decoded, final in
389388

390389
assertEquals("EOF", -1, in.read());
391390
assertEquals("Still EOF", -1, in.read());
392-
assertTrue("Streaming base64 wrap-wrap-wrap!", Arrays.equals(output, decoded));
391+
assertArrayEquals("Streaming base64 wrap-wrap-wrap!", decoded, output);
393392
in.close();
394393
}
395394

‎src/test/java/org/apache/commons/codec/binary/Base64OutputStreamTest.java‎

Lines changed: 13 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -17,18 +17,18 @@
1717

1818
package org.apache.commons.codec.binary;
1919

20-
import static org.junit.Assert.assertEquals;
21-
import static org.junit.Assert.assertFalse;
22-
import static org.junit.Assert.assertTrue;
23-
import static org.junit.Assert.fail;
24-
2520
import java.io.ByteArrayOutputStream;
2621
import java.io.OutputStream;
27-
import java.util.Arrays;
2822

2923
import org.apache.commons.codec.CodecPolicy;
3024
import org.junit.Test;
3125

26+
import static org.junit.Assert.assertArrayEquals;
27+
import static org.junit.Assert.assertEquals;
28+
import static org.junit.Assert.assertFalse;
29+
import static org.junit.Assert.assertTrue;
30+
import static org.junit.Assert.fail;
31+
3232
/**
3333
* @since 1.4
3434
*/
@@ -195,15 +195,15 @@ private void testByChunk(final byte[] encoded, final byte[] decoded, final int c
195195
out.write(decoded);
196196
out.close();
197197
byte[] output = byteOut.toByteArray();
198-
assertTrue("Streaming chunked base64 encode", Arrays.equals(output, encoded));
198+
assertArrayEquals("Streaming chunked base64 encode", encoded, output);
199199

200200
// Now let's try decode.
201201
byteOut = new ByteArrayOutputStream();
202202
out = new Base64OutputStream(byteOut, false);
203203
out.write(encoded);
204204
out.close();
205205
output = byteOut.toByteArray();
206-
assertTrue("Streaming chunked base64 decode", Arrays.equals(output, decoded));
206+
assertArrayEquals("Streaming chunked base64 decode", decoded, output);
207207

208208
// I always wanted to do this! (wrap encoder with decoder etc etc).
209209
byteOut = new ByteArrayOutputStream();
@@ -216,7 +216,7 @@ private void testByChunk(final byte[] encoded, final byte[] decoded, final int c
216216
out.close();
217217
output = byteOut.toByteArray();
218218

219-
assertTrue("Streaming chunked base64 wrap-wrap-wrap!", Arrays.equals(output, decoded));
219+
assertArrayEquals("Streaming chunked base64 wrap-wrap-wrap!", decoded, output);
220220
}
221221

222222
/**
@@ -247,7 +247,7 @@ private void testByteByByte(final byte[] encoded, final byte[] decoded, final in
247247
}
248248
out.close();
249249
byte[] output = byteOut.toByteArray();
250-
assertTrue("Streaming byte-by-byte base64 encode", Arrays.equals(output, encoded));
250+
assertArrayEquals("Streaming byte-by-byte base64 encode", encoded, output);
251251

252252
// Now let's try decode.
253253
byteOut = new ByteArrayOutputStream();
@@ -257,7 +257,7 @@ private void testByteByByte(final byte[] encoded, final byte[] decoded, final in
257257
}
258258
out.close();
259259
output = byteOut.toByteArray();
260-
assertTrue("Streaming byte-by-byte base64 decode", Arrays.equals(output, decoded));
260+
assertArrayEquals("Streaming byte-by-byte base64 decode", decoded, output);
261261

262262
// Now let's try decode with tonnes of flushes.
263263
byteOut = new ByteArrayOutputStream();
@@ -268,7 +268,7 @@ private void testByteByByte(final byte[] encoded, final byte[] decoded, final in
268268
}
269269
out.close();
270270
output = byteOut.toByteArray();
271-
assertTrue("Streaming byte-by-byte flush() base64 decode", Arrays.equals(output, decoded));
271+
assertArrayEquals("Streaming byte-by-byte flush() base64 decode", decoded, output);
272272

273273
// I always wanted to do this! (wrap encoder with decoder etc etc).
274274
byteOut = new ByteArrayOutputStream();
@@ -283,7 +283,7 @@ private void testByteByByte(final byte[] encoded, final byte[] decoded, final in
283283
out.close();
284284
output = byteOut.toByteArray();
285285

286-
assertTrue("Streaming byte-by-byte base64 wrap-wrap-wrap!", Arrays.equals(output, decoded));
286+
assertArrayEquals("Streaming byte-by-byte base64 wrap-wrap-wrap!", decoded, output);
287287
}
288288

289289
/**

0 commit comments

Comments
 (0)