chore/test: Replace qualifications with imports

Author: spryslmatej

compiler/src/test/java/org/capnproto/test/EncodingTest.java

@@ -26,6 +26,8 @@
 
 import java.nio.ByteBuffer;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 public class ArrayInputStreamTest {
   @Test
   public void testEmptyArray() throws java.io.IOException {
@@ -34,15 +36,15 @@ public void testEmptyArray() throws java.io.IOException {
 
     // read() should return -1 at the end of the stream
     // https://docs.oracle.com/javase/7/docs/api/java/nio/channels/ReadableByteChannel.html
-    Assertions.assertEquals(stream.read(dst), -1);
+    assertEquals(stream.read(dst), -1);
   }
 
   @Test
   public void testRequestMoreBytesThanArePresent() throws java.io.IOException {
     byte[] oneByte = new byte[]{42};
     ArrayInputStream stream = new ArrayInputStream(ByteBuffer.wrap(oneByte));
     ByteBuffer dst = ByteBuffer.allocate(10);
-    Assertions.assertEquals(stream.read(dst), 1);
-    Assertions.assertEquals(stream.read(dst), -1); // end of stream
+    assertEquals(stream.read(dst), 1);
+    assertEquals(stream.read(dst), -1); // end of stream
   }
 }

compiler/src/test/java/org/capnproto/test/TestUtil.java

@@ -3,24 +3,26 @@
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 public class DefaultAllocatorTest {
     @Test
     public void maxSegmentBytes() {
       DefaultAllocator allocator = new DefaultAllocator();
-      Assertions.assertEquals(allocator.allocationStrategy,
+      assertEquals(allocator.allocationStrategy,
                           BuilderArena.AllocationStrategy.GROW_HEURISTICALLY);
       allocator.maxSegmentBytes = (1 << 25) - 1;
 
       int allocationSize = 1 << 24;
       allocator.setNextAllocationSizeBytes(allocationSize);
 
-      Assertions.assertEquals(allocationSize,
+      assertEquals(allocationSize,
                           allocator.allocateSegment(allocationSize).capacity());
 
-      Assertions.assertEquals(allocator.maxSegmentBytes,
+      assertEquals(allocator.maxSegmentBytes,
                           allocator.allocateSegment(allocationSize).capacity());
 
-      Assertions.assertEquals(allocator.maxSegmentBytes,
+      assertEquals(allocator.maxSegmentBytes,
                           allocator.allocateSegment(allocationSize).capacity());
     }
 }

runtime/src/test/java/org/capnproto/ArrayInputStreamTest.java

@@ -6,6 +6,9 @@
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
 public class LayoutTest {
 
     private static final int MAX_NESTING_LIMIT = 0x7fffffff;
@@ -30,40 +33,40 @@ public void testSimpleRawDataStruct() {
 
         StructReader reader = WireHelpers.readStructPointer(new BareStructReader(), arena.tryGetSegment(0), 0, null, 0, MAX_NESTING_LIMIT);
 
-        Assertions.assertEquals(reader._getLongField(0), 0xefcdab8967452301L);
-        Assertions.assertEquals(reader._getLongField(1), 0L);
-
-        Assertions.assertEquals(reader._getIntField(0), 0x67452301);
-        Assertions.assertEquals(reader._getIntField(1), 0xefcdab89);
-        Assertions.assertEquals(reader._getIntField(2), 0);
-
-        Assertions.assertEquals(reader._getShortField(0), (short)0x2301);
-        Assertions.assertEquals(reader._getShortField(1), (short)0x6745);
-        Assertions.assertEquals(reader._getShortField(2), (short)0xab89);
-        Assertions.assertEquals(reader._getShortField(3), (short)0xefcd);
-        Assertions.assertEquals(reader._getShortField(4), (short)0);
-
-        Assertions.assertEquals(reader._getBooleanField(0), true);
-        Assertions.assertEquals(reader._getBooleanField(1), false);
-        Assertions.assertEquals(reader._getBooleanField(2), false);
-
-        Assertions.assertEquals(reader._getBooleanField(3), false);
-        Assertions.assertEquals(reader._getBooleanField(4), false);
-        Assertions.assertEquals(reader._getBooleanField(5), false);
-        Assertions.assertEquals(reader._getBooleanField(6), false);
-        Assertions.assertEquals(reader._getBooleanField(7), false);
-
-        Assertions.assertEquals(reader._getBooleanField(8), true);
-        Assertions.assertEquals(reader._getBooleanField(9), true);
-        Assertions.assertEquals(reader._getBooleanField(10), false);
-        Assertions.assertEquals(reader._getBooleanField(11), false);
-        Assertions.assertEquals(reader._getBooleanField(12), false);
-        Assertions.assertEquals(reader._getBooleanField(13), true);
-        Assertions.assertEquals(reader._getBooleanField(14), false);
-        Assertions.assertEquals(reader._getBooleanField(15), false);
-
-        Assertions.assertEquals(reader._getBooleanField(63), true);
-        Assertions.assertEquals(reader._getBooleanField(64), false);
+        assertEquals(reader._getLongField(0), 0xefcdab8967452301L);
+        assertEquals(reader._getLongField(1), 0L);
+
+        assertEquals(reader._getIntField(0), 0x67452301);
+        assertEquals(reader._getIntField(1), 0xefcdab89);
+        assertEquals(reader._getIntField(2), 0);
+
+        assertEquals(reader._getShortField(0), (short)0x2301);
+        assertEquals(reader._getShortField(1), (short)0x6745);
+        assertEquals(reader._getShortField(2), (short)0xab89);
+        assertEquals(reader._getShortField(3), (short)0xefcd);
+        assertEquals(reader._getShortField(4), (short)0);
+
+        assertEquals(reader._getBooleanField(0), true);
+        assertEquals(reader._getBooleanField(1), false);
+        assertEquals(reader._getBooleanField(2), false);
+
+        assertEquals(reader._getBooleanField(3), false);
+        assertEquals(reader._getBooleanField(4), false);
+        assertEquals(reader._getBooleanField(5), false);
+        assertEquals(reader._getBooleanField(6), false);
+        assertEquals(reader._getBooleanField(7), false);
+
+        assertEquals(reader._getBooleanField(8), true);
+        assertEquals(reader._getBooleanField(9), true);
+        assertEquals(reader._getBooleanField(10), false);
+        assertEquals(reader._getBooleanField(11), false);
+        assertEquals(reader._getBooleanField(12), false);
+        assertEquals(reader._getBooleanField(13), true);
+        assertEquals(reader._getBooleanField(14), false);
+        assertEquals(reader._getBooleanField(15), false);
+
+        assertEquals(reader._getBooleanField(63), true);
+        assertEquals(reader._getBooleanField(64), false);
     }
 
     /**
@@ -86,7 +89,7 @@ public void readStructPointerShouldThrowDecodeExceptionOnOutOfBoundsStructPointe
 
         ReaderArena arena = new ReaderArena(new ByteBuffer[]{ buffer }, 0x7fffffffffffffffL);
 
-        Assertions.assertThrows(DecodeException.class, () -> WireHelpers.readStructPointer(new BareStructReader(), arena.tryGetSegment(0), 0, null, 0, MAX_NESTING_LIMIT));
+        assertThrows(DecodeException.class, () -> WireHelpers.readStructPointer(new BareStructReader(), arena.tryGetSegment(0), 0, null, 0, MAX_NESTING_LIMIT));
     }
 
 
@@ -114,7 +117,7 @@ public void readListPointerShouldThrowDecodeExceptionOnOutOfBoundsCompositeListP
 
         ReaderArena arena = new ReaderArena(new ByteBuffer[]{buffer}, 0x7fffffffffffffffL);
 
-        Assertions.assertThrows(DecodeException.class, () -> WireHelpers.readListPointer(new BareListReader(), arena.tryGetSegment(0), 0, null, 0, (byte) 0, MAX_NESTING_LIMIT));
+        assertThrows(DecodeException.class, () -> WireHelpers.readListPointer(new BareListReader(), arena.tryGetSegment(0), 0, null, 0, (byte) 0, MAX_NESTING_LIMIT));
     }
 
     private class BareStructBuilder implements StructBuilder.Factory<StructBuilder> {
@@ -165,17 +168,17 @@ private void setUpStruct(StructBuilder builder) {
     }
 
     private void checkStruct(StructBuilder builder) {
-        Assertions.assertEquals(0x1011121314151617L, builder._getLongField(0));
-        Assertions.assertEquals(0x20212223, builder._getIntField(2));
-        Assertions.assertEquals(0x3031, builder._getShortField(6));
-        Assertions.assertEquals(0x40, builder._getByteField(14));
-        Assertions.assertEquals(false, builder._getBooleanField(120));
-        Assertions.assertEquals(false, builder._getBooleanField(121));
-        Assertions.assertEquals(true, builder._getBooleanField(122));
-        Assertions.assertEquals(false, builder._getBooleanField(123));
-        Assertions.assertEquals(true, builder._getBooleanField(124));
-        Assertions.assertEquals(true, builder._getBooleanField(125));
-        Assertions.assertEquals(true, builder._getBooleanField(126));
-        Assertions.assertEquals(false, builder._getBooleanField(127));
+        assertEquals(0x1011121314151617L, builder._getLongField(0));
+        assertEquals(0x20212223, builder._getIntField(2));
+        assertEquals(0x3031, builder._getShortField(6));
+        assertEquals(0x40, builder._getByteField(14));
+        assertEquals(false, builder._getBooleanField(120));
+        assertEquals(false, builder._getBooleanField(121));
+        assertEquals(true, builder._getBooleanField(122));
+        assertEquals(false, builder._getBooleanField(123));
+        assertEquals(true, builder._getBooleanField(124));
+        assertEquals(true, builder._getBooleanField(125));
+        assertEquals(true, builder._getBooleanField(126));
+        assertEquals(false, builder._getBooleanField(127));
     }
 }

runtime/src/test/java/org/capnproto/DefaultAllocatorTest.java

@@ -5,6 +5,8 @@
 
 import java.nio.ByteBuffer;
 
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
 public class ListBuilderTest {
 
     @Test
@@ -14,6 +16,6 @@ public void _setBooleanElementShouldNotOverflowDuringPositionOffsetCalculation()
         SegmentBuilder segmentBuilder = new SegmentBuilder(buffer, builderArena);
         ListBuilder listBuilder = new ListBuilder(segmentBuilder, 0, 0, 2, 0, (short) 0);
 
-        Assertions.assertThrows(IndexOutOfBoundsException.class, () -> listBuilder._setBooleanElement(Integer.MAX_VALUE, true));
+        assertThrows(IndexOutOfBoundsException.class, () -> listBuilder._setBooleanElement(Integer.MAX_VALUE, true));
     }
 }

runtime/src/test/java/org/capnproto/LayoutTest.java

@@ -7,27 +7,29 @@
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 public class SegmentReaderTest {
 
     @Test
     public void in_boundsCalculationShouldNotOverflow() {
         ByteBuffer byteBuffer = ByteBuffer.allocate(64);
         SegmentReader segmentReader = new SegmentReader(byteBuffer, null);
-        Assertions.assertEquals(segmentReader.isInBounds(0, Integer.MAX_VALUE), false);
+        assertEquals(segmentReader.isInBounds(0, Integer.MAX_VALUE), false);
     }
 
     @Test
     public void oneWordAtLastWordShouldBeInBounds() {
         ByteBuffer byteBuffer = ByteBuffer.allocate(64);
         SegmentReader segmentReader = new SegmentReader(byteBuffer, null);
-        Assertions.assertEquals(segmentReader.isInBounds(7, 1), true);
+        assertEquals(segmentReader.isInBounds(7, 1), true);
     }
 
     @Test
     public void twoWordsAtLastWordShouldNotBeInBounds() {
         ByteBuffer byteBuffer = ByteBuffer.allocate(64);
         SegmentReader segmentReader = new SegmentReader(byteBuffer, null);
-        Assertions.assertEquals(segmentReader.isInBounds(7, 2), false);
+        assertEquals(segmentReader.isInBounds(7, 2), false);
     }
 
     @Test
@@ -76,15 +78,15 @@ public void validSegmentWithNegativeOffsetShouldBeInBounds() {
         refTarget = WirePointer.target(refOffset, ref);
         dataSizeWords = StructPointer.dataSize(ref);
         wordSize = dataSizeWords + StructPointer.ptrCount(ref);
-        Assertions.assertEquals(segment.isInBounds(refTarget, wordSize), true);
+        assertEquals(segment.isInBounds(refTarget, wordSize), true);
 
         /* Read inner Struct: ComObject. */
         refOffset = refTarget + dataSizeWords; /* At the inner STRUCT POINTER */
         ref = segment.get(refOffset);
         refTarget = WirePointer.target(refOffset, ref);
         dataSizeWords = StructPointer.dataSize(ref);
         wordSize = dataSizeWords + StructPointer.ptrCount(ref);
-        Assertions.assertEquals(segment.isInBounds(refTarget, wordSize), true);
+        assertEquals(segment.isInBounds(refTarget, wordSize), true);
     }
 
 }

runtime/src/test/java/org/capnproto/ListBuilderTest.java

@@ -9,6 +9,11 @@
 import java.util.Arrays;
 import java.util.concurrent.TimeUnit;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
 public class SerializePackedTest {
 
     @Test
@@ -63,10 +68,10 @@ private void assertPacksTo(byte[] unpacked, byte[] packed) {
             try {
                 packedOutputStream.write(ByteBuffer.wrap(unpacked));
             } catch (IOException e) {
-                Assertions.fail("Failed writing to PackedOutputStream");
+                fail("Failed writing to PackedOutputStream");
             }
 
-            Assertions.assertTrue(Arrays.equals(bytes, packed));
+            assertTrue(Arrays.equals(bytes, packed));
         }
 
         {
@@ -77,25 +82,25 @@ private void assertPacksTo(byte[] unpacked, byte[] packed) {
             try {
                 n = stream.read(ByteBuffer.wrap(bytes));
             } catch (IOException e) {
-                Assertions.fail("Failed reading from PackedInputStream");
+                fail("Failed reading from PackedInputStream");
             }
 
-            Assertions.assertEquals(n, unpacked.length);
-            Assertions.assertTrue(Arrays.equals(bytes, unpacked));
+            assertEquals(n, unpacked.length);
+            assertTrue(Arrays.equals(bytes, unpacked));
         }
     }
 
     @Test
     @Timeout(value = 1000, unit = TimeUnit.MILLISECONDS)
     public void read_shouldThrowDecodingExceptionOnEmptyArrayInputStream() throws IOException {
         byte[] emptyByteArray = {};
-        Assertions.assertThrows(DecodeException.class, () -> SerializePacked.read(new ArrayInputStream(ByteBuffer.wrap(emptyByteArray)), ReaderOptions.DEFAULT_READER_OPTIONS));
+        assertThrows(DecodeException.class, () -> SerializePacked.read(new ArrayInputStream(ByteBuffer.wrap(emptyByteArray)), ReaderOptions.DEFAULT_READER_OPTIONS));
     }
 
     @Test
     @Timeout(value = 1000, unit = TimeUnit.MILLISECONDS)
     public void read_shouldThrowDecodingExceptionWhenTryingToReadMoreThanAvailableFromArrayInputStream() throws IOException {
         byte[] bytes = {17, 0, 127, 0, 0, 0, 0}; //segment0 size of 127 words, which is way larger than the tiny 7 byte input
-        Assertions.assertThrows(DecodeException.class, () -> SerializePacked.read(new ArrayInputStream(ByteBuffer.wrap(bytes)), ReaderOptions.DEFAULT_READER_OPTIONS));
+        assertThrows(DecodeException.class, () -> SerializePacked.read(new ArrayInputStream(ByteBuffer.wrap(bytes)), ReaderOptions.DEFAULT_READER_OPTIONS));
     }
 }