Inline ByteStreamsTest#assertEquals(byte[], byte[])

#codehealth

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=315898541

Author: mruppaner

android/guava-tests/test/com/google/common/io/ByteStreamsTest.java

@@ -48,7 +48,7 @@ public void testCopyChannel() throws IOException {
 
     ReadableByteChannel inChannel = Channels.newChannel(new ByteArrayInputStream(expected));
     ByteStreams.copy(inChannel, outChannel);
-    assertEquals(expected, out.toByteArray());
+    assertThat(out.toByteArray()).isEqualTo(expected);
   }
 
   public void testCopyFileChannel() throws IOException {
@@ -68,7 +68,7 @@ public void testCopyFileChannel() throws IOException {
     }
     byte[] actual = out.toByteArray();
     for (int i = 0; i < 500 * chunkSize; i += chunkSize) {
-      assertEquals(dummyData, Arrays.copyOfRange(actual, i, i + chunkSize));
+      assertThat(Arrays.copyOfRange(actual, i, i + chunkSize)).isEqualTo(dummyData);
     }
   }
 
@@ -119,15 +119,15 @@ public void testReadFully() throws IOException {
 
     Arrays.fill(b, (byte) 0);
     ByteStreams.readFully(newTestStream(10), b, 0, 0);
-    assertEquals(new byte[10], b);
+    assertThat(b).isEqualTo(new byte[10]);
 
     Arrays.fill(b, (byte) 0);
     ByteStreams.readFully(newTestStream(10), b, 0, 10);
-    assertEquals(newPreFilledByteArray(10), b);
+    assertThat(b).isEqualTo(newPreFilledByteArray(10));
 
     Arrays.fill(b, (byte) 0);
     ByteStreams.readFully(newTestStream(10), b, 0, 5);
-    assertEquals(new byte[] {0, 1, 2, 3, 4, 0, 0, 0, 0, 0}, b);
+    assertThat(b).isEqualTo(new byte[] {0, 1, 2, 3, 4, 0, 0, 0, 0, 0});
   }
 
   public void testSkipFully() throws IOException {
@@ -177,7 +177,7 @@ public void testNewDataInput_readFully() {
     ByteArrayDataInput in = ByteStreams.newDataInput(bytes);
     byte[] actual = new byte[bytes.length];
     in.readFully(actual);
-    assertEquals(bytes, actual);
+    assertThat(actual).isEqualTo(bytes);
   }
 
   public void testNewDataInput_readFullyAndThenSome() {
@@ -317,54 +317,54 @@ public void testNewDataOutput_writeInt() {
     ByteArrayDataOutput out = ByteStreams.newDataOutput();
     out.writeInt(0x12345678);
     out.writeInt(0x76543210);
-    assertEquals(bytes, out.toByteArray());
+    assertThat(out.toByteArray()).isEqualTo(bytes);
   }
 
   public void testNewDataOutput_sized() {
     ByteArrayDataOutput out = ByteStreams.newDataOutput(4);
     out.writeInt(0x12345678);
     out.writeInt(0x76543210);
-    assertEquals(bytes, out.toByteArray());
+    assertThat(out.toByteArray()).isEqualTo(bytes);
   }
 
   public void testNewDataOutput_writeLong() {
     ByteArrayDataOutput out = ByteStreams.newDataOutput();
     out.writeLong(0x1234567876543210L);
-    assertEquals(bytes, out.toByteArray());
+    assertThat(out.toByteArray()).isEqualTo(bytes);
   }
 
   public void testNewDataOutput_writeByteArray() {
     ByteArrayDataOutput out = ByteStreams.newDataOutput();
     out.write(bytes);
-    assertEquals(bytes, out.toByteArray());
+    assertThat(out.toByteArray()).isEqualTo(bytes);
   }
 
   public void testNewDataOutput_writeByte() {
     ByteArrayDataOutput out = ByteStreams.newDataOutput();
     out.write(0x12);
     out.writeByte(0x34);
-    assertEquals(new byte[] {0x12, 0x34}, out.toByteArray());
+    assertThat(out.toByteArray()).isEqualTo(new byte[] {0x12, 0x34});
   }
 
   public void testNewDataOutput_writeByteOffset() {
     ByteArrayDataOutput out = ByteStreams.newDataOutput();
     out.write(bytes, 4, 2);
     byte[] expected = {bytes[4], bytes[5]};
-    assertEquals(expected, out.toByteArray());
+    assertThat(out.toByteArray()).isEqualTo(expected);
   }
 
   public void testNewDataOutput_writeBoolean() {
     ByteArrayDataOutput out = ByteStreams.newDataOutput();
     out.writeBoolean(true);
     out.writeBoolean(false);
     byte[] expected = {(byte) 1, (byte) 0};
-    assertEquals(expected, out.toByteArray());
+    assertThat(out.toByteArray()).isEqualTo(expected);
   }
 
   public void testNewDataOutput_writeChar() {
     ByteArrayDataOutput out = ByteStreams.newDataOutput();
     out.writeChar('a');
-    assertEquals(new byte[] {0, 97}, out.toByteArray());
+    assertThat(out.toByteArray()).isEqualTo(new byte[] {0, 97});
   }
 
   // Hardcoded because of Android problems. See testUtf16Expected.
@@ -376,14 +376,14 @@ public void testNewDataOutput_writeChars() {
     out.writeChars("r\u00C9sum\u00C9");
     // need to remove byte order mark before comparing
     byte[] expected = Arrays.copyOfRange(utf16ExpectedWithBom, 2, 14);
-    assertEquals(expected, out.toByteArray());
+    assertThat(out.toByteArray()).isEqualTo(expected);
   }
 
   @AndroidIncompatible // https://code.google.com/p/android/issues/detail?id=196848
   public void testUtf16Expected() {
     byte[] hardcodedExpected = utf16ExpectedWithBom;
     byte[] computedExpected = "r\u00C9sum\u00C9".getBytes(Charsets.UTF_16);
-    assertEquals(hardcodedExpected, computedExpected);
+    assertThat(computedExpected).isEqualTo(hardcodedExpected);
   }
 
   public void testNewDataOutput_writeUTF() {
@@ -394,93 +394,93 @@ public void testNewDataOutput_writeUTF() {
     // writeUTF writes the length of the string in 2 bytes
     assertEquals(0, actual[0]);
     assertEquals(expected.length, actual[1]);
-    assertEquals(expected, Arrays.copyOfRange(actual, 2, actual.length));
+    assertThat(Arrays.copyOfRange(actual, 2, actual.length)).isEqualTo(expected);
   }
 
   public void testNewDataOutput_writeShort() {
     ByteArrayDataOutput out = ByteStreams.newDataOutput();
     out.writeShort(0x1234);
-    assertEquals(new byte[] {0x12, 0x34}, out.toByteArray());
+    assertThat(out.toByteArray()).isEqualTo(new byte[] {0x12, 0x34});
   }
 
   public void testNewDataOutput_writeDouble() {
     ByteArrayDataOutput out = ByteStreams.newDataOutput();
     out.writeDouble(Double.longBitsToDouble(0x1234567876543210L));
-    assertEquals(bytes, out.toByteArray());
+    assertThat(out.toByteArray()).isEqualTo(bytes);
   }
 
   public void testNewDataOutput_writeFloat() {
     ByteArrayDataOutput out = ByteStreams.newDataOutput();
     out.writeFloat(Float.intBitsToFloat(0x12345678));
     out.writeFloat(Float.intBitsToFloat(0x76543210));
-    assertEquals(bytes, out.toByteArray());
+    assertThat(out.toByteArray()).isEqualTo(bytes);
   }
 
   public void testNewDataOutput_BAOS() {
     ByteArrayOutputStream baos = new ByteArrayOutputStream();
     ByteArrayDataOutput out = ByteStreams.newDataOutput(baos);
     out.writeInt(0x12345678);
     assertEquals(4, baos.size());
-    assertEquals(new byte[] {0x12, 0x34, 0x56, 0x78}, baos.toByteArray());
+    assertThat(baos.toByteArray()).isEqualTo(new byte[] {0x12, 0x34, 0x56, 0x78});
   }
 
   private static final byte[] PRE_FILLED_100 = newPreFilledByteArray(100);
 
   public void testToByteArray() throws IOException {
     InputStream in = new ByteArrayInputStream(PRE_FILLED_100);
     byte[] b = ByteStreams.toByteArray(in);
-    assertEquals(PRE_FILLED_100, b);
+    assertThat(b).isEqualTo(PRE_FILLED_100);
   }
 
   public void testToByteArray_emptyStream() throws IOException {
     InputStream in = newTestStream(0);
     byte[] b = ByteStreams.toByteArray(in);
-    assertEquals(new byte[0], b);
+    assertThat(b).isEqualTo(new byte[0]);
   }
 
   public void testToByteArray_largeStream() throws IOException {
     // well, large enough to require multiple buffers
     byte[] expected = newPreFilledByteArray(10000000);
     InputStream in = new ByteArrayInputStream(expected);
     byte[] b = ByteStreams.toByteArray(in);
-    assertEquals(expected, b);
+    assertThat(b).isEqualTo(expected);
   }
 
   public void testToByteArray_withSize_givenCorrectSize() throws IOException {
     InputStream in = new ByteArrayInputStream(PRE_FILLED_100);
     byte[] b = ByteStreams.toByteArray(in, 100);
-    assertEquals(PRE_FILLED_100, b);
+    assertThat(b).isEqualTo(PRE_FILLED_100);
   }
 
   public void testToByteArray_withSize_givenSmallerSize() throws IOException {
     InputStream in = new ByteArrayInputStream(PRE_FILLED_100);
     byte[] b = ByteStreams.toByteArray(in, 80);
-    assertEquals(PRE_FILLED_100, b);
+    assertThat(b).isEqualTo(PRE_FILLED_100);
   }
 
   public void testToByteArray_withSize_givenLargerSize() throws IOException {
     InputStream in = new ByteArrayInputStream(PRE_FILLED_100);
     byte[] b = ByteStreams.toByteArray(in, 120);
-    assertEquals(PRE_FILLED_100, b);
+    assertThat(b).isEqualTo(PRE_FILLED_100);
   }
 
   public void testToByteArray_withSize_givenSizeZero() throws IOException {
     InputStream in = new ByteArrayInputStream(PRE_FILLED_100);
     byte[] b = ByteStreams.toByteArray(in, 0);
-    assertEquals(PRE_FILLED_100, b);
+    assertThat(b).isEqualTo(PRE_FILLED_100);
   }
 
   public void testToByteArray_withSize_givenSizeOneSmallerThanActual() throws IOException {
     InputStream in = new ByteArrayInputStream(PRE_FILLED_100);
     // this results in toByteArrayInternal being called when the stream is actually exhausted
     byte[] b = ByteStreams.toByteArray(in, 99);
-    assertEquals(PRE_FILLED_100, b);
+    assertThat(b).isEqualTo(PRE_FILLED_100);
   }
 
   public void testToByteArray_withSize_givenSizeTwoSmallerThanActual() throws IOException {
     InputStream in = new ByteArrayInputStream(PRE_FILLED_100);
     byte[] b = ByteStreams.toByteArray(in, 98);
-    assertEquals(PRE_FILLED_100, b);
+    assertThat(b).isEqualTo(PRE_FILLED_100);
   }
 
   public void testExhaust() throws IOException {
@@ -515,8 +515,8 @@ public long skip(long n) throws IOException {
 
   public void testReadBytes() throws IOException {
     final byte[] array = newPreFilledByteArray(1000);
-    assertEquals(
-        array, ByteStreams.readBytes(new ByteArrayInputStream(array), new TestByteProcessor()));
+    assertThat(ByteStreams.readBytes(new ByteArrayInputStream(array), new TestByteProcessor()))
+        .isEqualTo(array);
   }
 
   private static class TestByteProcessor implements ByteProcessor<byte[]> {
@@ -543,7 +543,8 @@ public void testByteProcessorStopEarly() throws IOException {
             new ByteProcessor<Integer>() {
               @Override
               public boolean processBytes(byte[] buf, int off, int len) {
-                assertEquals(Arrays.copyOfRange(buf, off, off + len), newPreFilledByteArray(8192));
+                assertThat(newPreFilledByteArray(8192))
+                    .isEqualTo(Arrays.copyOfRange(buf, off, off + len));
                 return false;
               }
 
@@ -670,9 +671,4 @@ public boolean markSupported() {
       return false;
     }
   }
-
-  // TODO(cpovirk): Inline this.
-  private static void assertEquals(byte[] expected, byte[] actual) {
-    assertThat(actual).isEqualTo(expected);
-  }
 }