Better test method names

Author: garydgregory

src/test/java/org/apache/commons/io/channels/AbstractSeekableByteChannelTest.java

@@ -52,39 +52,39 @@ abstract class AbstractSeekableByteChannelTest {
     class BasicTest {
 
         @Test
-        void testInitialPosition() throws IOException {
-            assertEquals(0, channel.position());
+        void testCloseMultipleTimes() throws IOException {
+            channel.close();
+            channel.close(); // Should not throw
+            assertFalse(channel.isOpen());
         }
 
         @Test
-        void testIsClosedAfterClose() throws IOException {
+        void testIsOpenAfterClose() throws IOException {
             channel.close();
             assertFalse(channel.isOpen());
         }
 
         @Test
-        void testMultipleClose() throws IOException {
-            channel.close();
-            channel.close(); // Should not throw
-            assertFalse(channel.isOpen());
+        void testIsOpennOnNew() {
+            assertTrue(channel.isOpen());
         }
 
         @Test
-        void testNewEntitySize() throws IOException {
-            assertEquals(0, channel.size());
+        void testPositionOnNew() throws IOException {
+            assertEquals(0, channel.position());
         }
 
         @Test
-        void testNewIsOpen() {
-            assertTrue(channel.isOpen());
+        void testSizeOnNew() throws IOException {
+            assertEquals(0, channel.size());
         }
     }
 
     @Nested
     class IntegrationTest {
 
         @Test
-        void ConcurrentPositionAndSizeQueries() throws IOException {
+        void testConcurrentPositionAndSizeQueries() throws IOException {
             final byte[] data = "test data".getBytes();
             channel.write(ByteBuffer.wrap(data));
             final long size = channel.size();
@@ -167,11 +167,6 @@ void testWritePositionReadVerify() throws IOException {
     @Nested
     class PositionTest {
 
-        @Test
-        void testNegativePosition() {
-            assertThrows(IllegalArgumentException.class, () -> channel.position(-1));
-        }
-
         @Test
         void testPositionBeyondSize() throws IOException {
             channel.write(ByteBuffer.wrap("test".getBytes()));
@@ -193,6 +188,11 @@ void testPositionInBounds(final long newPosition, final long expectedPosition) t
             assertEquals(expectedPosition, channel.position());
         }
 
+        @Test
+        void testPositionNegative() {
+            assertThrows(IllegalArgumentException.class, () -> channel.position(-1));
+        }
+
         @Test
         void testPositionOnClosed() throws IOException {
             channel.close();
@@ -278,12 +278,20 @@ void testReadSingleByte() throws IOException {
     class SizeTest {
 
         @Test
-        void testSameSizeOnOverwrite() throws IOException {
-            channel.write(ByteBuffer.wrap("Hello World".getBytes()));
+        void testSizeAfterTruncateToLargerSize() throws IOException {
+            channel.write(ByteBuffer.wrap("Hello".getBytes()));
+            assertEquals(5, channel.size());
+            channel.truncate(10);
+            assertEquals(5, channel.size()); // Size should remain unchanged
+        }
+
+        @Test
+        void testSizeAfterWrite() throws IOException {
+            assertEquals(0, channel.size());
+            channel.write(ByteBuffer.wrap("Hello".getBytes()));
+            assertEquals(5, channel.size());
+            channel.write(ByteBuffer.wrap(" World".getBytes()));
             assertEquals(11, channel.size());
-            channel.position(6);
-            channel.write(ByteBuffer.wrap("Test".getBytes()));
-            assertEquals(11, channel.size()); // Size should not change
         }
 
         @Test
@@ -292,6 +300,15 @@ void testSizeOnClosed() throws IOException {
             assertThrows(ClosedChannelException.class, () -> channel.size());
         }
 
+        @Test
+        void testSizeSameOnOverwrite() throws IOException {
+            channel.write(ByteBuffer.wrap("Hello World".getBytes()));
+            assertEquals(11, channel.size());
+            channel.position(6);
+            channel.write(ByteBuffer.wrap("Test".getBytes()));
+            assertEquals(11, channel.size()); // Size should not change
+        }
+
         @Test
         void testTruncateNegative() {
             assertThrows(IllegalArgumentException.class, () -> channel.truncate(-1));
@@ -308,23 +325,6 @@ void testTruncateShrinks() throws IOException {
                 assertEquals(5, channel.position());
             }
         }
-
-        @Test
-        void testTruncateToLargerSize() throws IOException {
-            channel.write(ByteBuffer.wrap("Hello".getBytes()));
-            assertEquals(5, channel.size());
-            channel.truncate(10);
-            assertEquals(5, channel.size()); // Size should remain unchanged
-        }
-
-        @Test
-        void testWriteGrowsSize() throws IOException {
-            assertEquals(0, channel.size());
-            channel.write(ByteBuffer.wrap("Hello".getBytes()));
-            assertEquals(5, channel.size());
-            channel.write(ByteBuffer.wrap(" World".getBytes()));
-            assertEquals(11, channel.size());
-        }
     }
 
     @Nested
@@ -367,6 +367,13 @@ void testWriteSingleByte() throws IOException {
             assertEquals(1, channel.size());
         }
 
+        @Test
+        void testWriteToClosedChannel() throws IOException {
+            channel.close();
+            final ByteBuffer buffer = ByteBuffer.wrap("test".getBytes());
+            assertThrows(ClosedChannelException.class, () -> channel.write(buffer));
+        }
+
         @Test
         void tesWriteBytes() throws IOException {
             final byte[] data = "Hello, World!".getBytes();
@@ -376,13 +383,6 @@ void tesWriteBytes() throws IOException {
             assertEquals(data.length, channel.position());
             assertEquals(data.length, channel.size());
         }
-
-        @Test
-        void writeToClosedChannel() throws IOException {
-            channel.close();
-            final ByteBuffer buffer = ByteBuffer.wrap("test".getBytes());
-            assertThrows(ClosedChannelException.class, () -> channel.write(buffer));
-        }
     }
 
     private SeekableByteChannel channel;