Sort test methods.

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/codec/trunk@1637889 13f79535-47bb-0310-9956-ffa450edef68

Author: garydgregory

src/test/java/org/apache/commons/codec/binary/HexTest.java

@@ -206,13 +206,8 @@ public void testDecodeByteArrayEmpty() throws DecoderException {
     }
 
     @Test
-    public void testDecodeByteBufferEmpty() throws DecoderException {
-        assertTrue(Arrays.equals(new byte[0], new Hex().decode(ByteBuffer.allocate(0))));
-    }
-
-    @Test
-    public void testDecodeCharArrayEmpty() throws DecoderException {
-        assertTrue(Arrays.equals(new byte[0], Hex.decodeHex(new char[0])));
+    public void testDecodeByteArrayObjectEmpty() throws DecoderException {
+        assertTrue(Arrays.equals(new byte[0], (byte[]) new Hex().decode((Object) new byte[0])));
     }
 
     @Test
@@ -225,6 +220,16 @@ public void testDecodeByteArrayOddCharacters() {
         }
     }
 
+    @Test
+    public void testDecodeByteBufferEmpty() throws DecoderException {
+        assertTrue(Arrays.equals(new byte[0], new Hex().decode(ByteBuffer.allocate(0))));
+    }
+
+    @Test
+    public void testDecodeByteBufferObjectEmpty() throws DecoderException {
+        assertTrue(Arrays.equals(new byte[0], (byte[]) new Hex().decode((Object) ByteBuffer.allocate(0))));
+    }
+
     @Test
     public void testDecodeByteBufferOddCharacters() {
         ByteBuffer buffer = ByteBuffer.allocate(1);
@@ -237,6 +242,11 @@ public void testDecodeByteBufferOddCharacters() {
         }
     }
 
+    @Test
+    public void testDecodeCharArrayEmpty() throws DecoderException {
+        assertTrue(Arrays.equals(new byte[0], Hex.decodeHex(new char[0])));
+    }
+
     @Test
     public void testDecodeClassCastException() {
         try {
@@ -278,13 +288,23 @@ public void testDecodeStringEmpty() throws DecoderException {
     }
 
     @Test
-    public void testDecodeByteArrayObjectEmpty() throws DecoderException {
-        assertTrue(Arrays.equals(new byte[0], (byte[]) new Hex().decode((Object) new byte[0])));
+    public void testEncodeByteArrayEmpty() throws EncoderException {
+        assertTrue(Arrays.equals(new byte[0], new Hex().encode(new byte[0])));
     }
 
     @Test
-    public void testDecodeByteBufferObjectEmpty() throws DecoderException {
-        assertTrue(Arrays.equals(new byte[0], (byte[]) new Hex().decode((Object) ByteBuffer.allocate(0))));
+    public void testEncodeByteArrayObjectEmpty() throws EncoderException {
+        assertTrue(Arrays.equals(new char[0], (char[]) new Hex().encode((Object) new byte[0])));
+    }
+
+    @Test
+    public void testEncodeByteBufferEmpty() throws EncoderException {
+        assertTrue(Arrays.equals(new byte[0], new Hex().encode(ByteBuffer.allocate(0))));
+    }
+
+    @Test
+    public void testEncodeByteBufferObjectEmpty() throws EncoderException {
+        assertTrue(Arrays.equals(new char[0], (char[]) new Hex().encode((Object) ByteBuffer.allocate(0))));
     }
 
     @Test
@@ -336,12 +356,6 @@ public void testEncodeHexByteArrayEmpty() throws EncoderException {
         assertTrue(Arrays.equals(new byte[0], new Hex().encode(new byte[0])));
     }
 
-    @Test
-    public void testEncodeHexByteBufferEmpty() throws EncoderException {
-        assertTrue(Arrays.equals(new char[0], Hex.encodeHex(ByteBuffer.allocate(0))));
-        assertTrue(Arrays.equals(new byte[0], new Hex().encode(ByteBuffer.allocate(0))));
-    }
-
     @Test
     public void testEncodeHexByteArrayHelloWorldLowerCaseHex() {
         final byte[] b = StringUtils.getBytesUtf8("Hello World");
@@ -356,29 +370,41 @@ public void testEncodeHexByteArrayHelloWorldLowerCaseHex() {
     }
 
     @Test
-    public void testEncodeHexByteBufferHelloWorldLowerCaseHex() {
-        final ByteBuffer b = StringUtils.getByteBufferUtf8("Hello World");
-        final String expected = "48656c6c6f20576f726c64";
+    public void testEncodeHexByteArrayHelloWorldUpperCaseHex() {
+        final byte[] b = StringUtils.getBytesUtf8("Hello World");
+        final String expected = "48656C6C6F20576F726C64";
         char[] actual;
         actual = Hex.encodeHex(b);
-        assertEquals(expected, new String(actual));
+        assertFalse(expected.equals(new String(actual)));
         actual = Hex.encodeHex(b, true);
-        assertEquals(expected, new String(actual));
-        actual = Hex.encodeHex(b, false);
         assertFalse(expected.equals(new String(actual)));
+        actual = Hex.encodeHex(b, false);
+        assertTrue(expected.equals(new String(actual)));
     }
 
     @Test
-    public void testEncodeHexByteArrayHelloWorldUpperCaseHex() {
-        final byte[] b = StringUtils.getBytesUtf8("Hello World");
-        final String expected = "48656C6C6F20576F726C64";
+    public void testEncodeHexByteArrayZeroes() {
+        final char[] c = Hex.encodeHex(new byte[36]);
+        assertEquals("000000000000000000000000000000000000000000000000000000000000000000000000", new String(c));
+    }
+
+    @Test
+    public void testEncodeHexByteBufferEmpty() throws EncoderException {
+        assertTrue(Arrays.equals(new char[0], Hex.encodeHex(ByteBuffer.allocate(0))));
+        assertTrue(Arrays.equals(new byte[0], new Hex().encode(ByteBuffer.allocate(0))));
+    }
+
+    @Test
+    public void testEncodeHexByteBufferHelloWorldLowerCaseHex() {
+        final ByteBuffer b = StringUtils.getByteBufferUtf8("Hello World");
+        final String expected = "48656c6c6f20576f726c64";
         char[] actual;
         actual = Hex.encodeHex(b);
-        assertFalse(expected.equals(new String(actual)));
+        assertEquals(expected, new String(actual));
         actual = Hex.encodeHex(b, true);
-        assertFalse(expected.equals(new String(actual)));
+        assertEquals(expected, new String(actual));
         actual = Hex.encodeHex(b, false);
-        assertTrue(expected.equals(new String(actual)));
+        assertFalse(expected.equals(new String(actual)));
     }
 
     @Test
@@ -394,12 +420,6 @@ public void testEncodeHexByteBufferHelloWorldUpperCaseHex() {
         assertTrue(expected.equals(new String(actual)));
     }
 
-    @Test
-    public void testEncodeHexByteArrayZeroes() {
-        final char[] c = Hex.encodeHex(new byte[36]);
-        assertEquals("000000000000000000000000000000000000000000000000000000000000000000000000", new String(c));
-    }
-
     @Test
     public void testEncodeHexByteBufferZeroes() {
         final char[] c = Hex.encodeHex(ByteBuffer.allocate(36));
@@ -421,26 +441,6 @@ public void testGetCharsetName() throws UnsupportedEncodingException, DecoderExc
         Assert.assertEquals(Charsets.UTF_8.name(), new Hex(Charsets.UTF_8).getCharsetName());
     }
 
-    @Test
-    public void testEncodeByteArrayEmpty() throws EncoderException {
-        assertTrue(Arrays.equals(new byte[0], new Hex().encode(new byte[0])));
-    }
-
-    @Test
-    public void testEncodeByteArrayObjectEmpty() throws EncoderException {
-        assertTrue(Arrays.equals(new char[0], (char[]) new Hex().encode((Object) new byte[0])));
-    }
-
-    @Test
-    public void testEncodeByteBufferEmpty() throws EncoderException {
-        assertTrue(Arrays.equals(new byte[0], new Hex().encode(ByteBuffer.allocate(0))));
-    }
-
-    @Test
-    public void testEncodeByteBufferObjectEmpty() throws EncoderException {
-        assertTrue(Arrays.equals(new char[0], (char[]) new Hex().encode((Object) ByteBuffer.allocate(0))));
-    }
-
     @Test
     public void testRequiredCharset() throws UnsupportedEncodingException, DecoderException {
         testCustomCharset("UTF-8", "testRequiredCharset");