Return-Path: X-Original-To: apmail-commons-commits-archive@minotaur.apache.org Delivered-To: apmail-commons-commits-archive@minotaur.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id 52BA0D563 for ; Tue, 2 Oct 2012 18:13:45 +0000 (UTC) Received: (qmail 84917 invoked by uid 500); 2 Oct 2012 18:13:45 -0000 Delivered-To: apmail-commons-commits-archive@commons.apache.org Received: (qmail 84866 invoked by uid 500); 2 Oct 2012 18:13:45 -0000 Mailing-List: contact commits-help@commons.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@commons.apache.org Delivered-To: mailing list commits@commons.apache.org Received: (qmail 84858 invoked by uid 99); 2 Oct 2012 18:13:45 -0000 Received: from nike.apache.org (HELO nike.apache.org) (192.87.106.230) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 02 Oct 2012 18:13:44 +0000 X-ASF-Spam-Status: No, hits=-2000.0 required=5.0 tests=ALL_TRUSTED X-Spam-Check-By: apache.org Received: from [140.211.11.4] (HELO eris.apache.org) (140.211.11.4) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 02 Oct 2012 18:13:39 +0000 Received: from eris.apache.org (localhost [127.0.0.1]) by eris.apache.org (Postfix) with ESMTP id 811562388900 for ; Tue, 2 Oct 2012 18:12:54 +0000 (UTC) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r1393073 - in /commons/proper/lang/trunk/src: main/java/org/apache/commons/lang3/Conversion.java test/java/org/apache/commons/lang3/ConversionTest.java Date: Tue, 02 Oct 2012 18:12:54 -0000 To: commits@commons.apache.org From: joehni@apache.org X-Mailer: svnmailer-1.0.8-patched Message-Id: <20121002181254.811562388900@eris.apache.org> Author: joehni Date: Tue Oct 2 18:12:53 2012 New Revision: 1393073 URL: http://svn.apache.org/viewvc?rev=1393073&view=rev Log: Use lowercase presentation for hex values as it is done in the JDK. Use JDK functionality where available. Modified: commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/Conversion.java commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/ConversionTest.java Modified: commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/Conversion.java URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/Conversion.java?rev=1393073&r1=1393072&r2=1393073&view=diff ============================================================================== --- commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/Conversion.java (original) +++ commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/Conversion.java Tue Oct 2 18:12:53 2012 @@ -67,50 +67,13 @@ public class Conversion { * @return an int equals to hexDigit */ public static int hexDigitToInt(char hexDigit) { - switch (hexDigit) { - case '0': - return 0; - case '1': - return 1; - case '2': - return 2; - case '3': - return 3; - case '4': - return 4; - case '5': - return 5; - case '6': - return 6; - case '7': - return 7; - case '8': - return 8; - case '9': - return 9; - case 'a':// fall through - case 'A': - return 10; - case 'b':// fall through - case 'B': - return 11; - case 'c':// fall through - case 'C': - return 12; - case 'd':// fall through - case 'D': - return 13; - case 'e':// fall through - case 'E': - return 14; - case 'f':// fall through - case 'F': - return 15; - default: + final int digit = Character.digit(hexDigit, 16); + if (digit < 0) { throw new IllegalArgumentException("Cannot interpret '" + hexDigit + "' as a hexadecimal digit"); } + return digit; } /** @@ -318,16 +281,16 @@ public class Conversion { if (src.length > srcPos + 3 && src[srcPos + 3]) { if (src.length > srcPos + 2 && src[srcPos + 2]) { if (src.length > srcPos + 1 && src[srcPos + 1]) { - if (src[srcPos]) return 'F'; - else return 'E'; + if (src[srcPos]) return 'f'; + else return 'e'; } else { - if (src[srcPos]) return 'D'; - else return 'C'; + if (src[srcPos]) return 'd'; + else return 'c'; } } else { if (src.length > srcPos + 1 && src[srcPos + 1]) { - if (src[srcPos]) return 'B'; - else return 'A'; + if (src[srcPos]) return 'b'; + else return 'a'; } else { if (src[srcPos]) return '9'; else return '8'; @@ -396,15 +359,15 @@ public class Conversion { if (src[srcPos + 3]) { if (src[srcPos + 2]) { if (src[srcPos + 1]) { - if (src[srcPos]) return 'F'; + if (src[srcPos]) return 'f'; else return '7'; } else { - if (src[srcPos]) return 'B'; + if (src[srcPos]) return 'b'; else return '3'; } } else { if (src[srcPos + 1]) { - if (src[srcPos]) return 'D'; + if (src[srcPos]) return 'd'; else return '5'; } else { if (src[srcPos]) return '9'; @@ -414,15 +377,15 @@ public class Conversion { } else { if (src[srcPos + 2]) { if (src[srcPos + 1]) { - if (src[srcPos]) return 'E'; + if (src[srcPos]) return 'e'; else return '6'; } else { - if (src[srcPos]) return 'A'; + if (src[srcPos]) return 'a'; else return '2'; } } else { if (src[srcPos + 1]) { - if (src[srcPos]) return 'C'; + if (src[srcPos]) return 'c'; else return '4'; } else { if (src[srcPos]) return '8'; @@ -473,16 +436,16 @@ public class Conversion { if (src[srcPos]) { if (src.length > srcPos + 1 && src[srcPos + 1]) { if (src.length > srcPos + 2 && src[srcPos + 2]) { - if (src.length > srcPos + 3 && src[srcPos + 3]) return 'F'; - else return 'E'; + if (src.length > srcPos + 3 && src[srcPos + 3]) return 'f'; + else return 'e'; } else { - if (src.length > srcPos + 3 && src[srcPos + 3]) return 'D'; - else return 'C'; + if (src.length > srcPos + 3 && src[srcPos + 3]) return 'd'; + else return 'c'; } } else { if (src.length > srcPos + 2 && src[srcPos + 2]) { - if (src.length > srcPos + 3 && src[srcPos + 3]) return 'B'; - else return 'A'; + if (src.length > srcPos + 3 && src[srcPos + 3]) return 'b'; + else return 'a'; } else { if (src.length > srcPos + 3 && src[srcPos + 3]) return '9'; else return '8'; @@ -527,42 +490,11 @@ public class Conversion { * @return a hexadecimal digit representing the 4 lsb of nibble */ public static char intToHexDigit(int nibble) { - switch (nibble) { - case 0x0: - return '0'; - case 0x1: - return '1'; - case 0x2: - return '2'; - case 0x3: - return '3'; - case 0x4: - return '4'; - case 0x5: - return '5'; - case 0x6: - return '6'; - case 0x7: - return '7'; - case 0x8: - return '8'; - case 0x9: - return '9'; - case 0xA: - return 'A'; - case 0xB: - return 'B'; - case 0xC: - return 'C'; - case 0xD: - return 'D'; - case 0xE: - return 'E'; - case 0xF: - return 'F'; - default: + char c = Character.forDigit(nibble, 16); + if (c == Character.MIN_VALUE) { throw new IllegalArgumentException("nibble value not between 0 and 15: " + nibble); } + return c; } /** @@ -591,15 +523,15 @@ public class Conversion { case 0x2: return '4'; case 0x3: - return 'C'; + return 'c'; case 0x4: return '2'; case 0x5: - return 'A'; + return 'a'; case 0x6: return '6'; case 0x7: - return 'E'; + return 'e'; case 0x8: return '1'; case 0x9: @@ -607,15 +539,15 @@ public class Conversion { case 0xA: return '5'; case 0xB: - return 'D'; + return 'd'; case 0xC: return '3'; case 0xD: - return 'B'; + return 'b'; case 0xE: return '7'; case 0xF: - return 'F'; + return 'f'; default: throw new IllegalArgumentException("nibble value not between 0 and 15: " + nibble); } Modified: commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/ConversionTest.java URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/ConversionTest.java?rev=1393073&r1=1393072&r2=1393073&view=diff ============================================================================== --- commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/ConversionTest.java (original) +++ commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/ConversionTest.java Tue Oct 2 18:12:53 2012 @@ -59,6 +59,12 @@ public class ConversionTest { assertEquals(14, Conversion.hexDigitToInt('e')); assertEquals(15, Conversion.hexDigitToInt('F')); assertEquals(15, Conversion.hexDigitToInt('f')); + try { + Conversion.hexDigitToInt('G'); + fail("Thrown " + IllegalArgumentException.class.getName() + " expected"); + } catch (final IllegalArgumentException e) { + // OK + } } /** @@ -88,6 +94,12 @@ public class ConversionTest { assertEquals(0x7, Conversion.hexDigitM0ToInt('e')); assertEquals(0xF, Conversion.hexDigitM0ToInt('F')); assertEquals(0xF, Conversion.hexDigitM0ToInt('f')); + try { + Conversion.hexDigitM0ToInt('G'); + fail("Thrown " + IllegalArgumentException.class.getName() + " expected"); + } catch (final IllegalArgumentException e) { + // OK + } } /** @@ -139,6 +151,12 @@ public class ConversionTest { new boolean[]{true, true, true, true}, Conversion.hexDigitToBools('F')); assertBoolArrayEquals( new boolean[]{true, true, true, true}, Conversion.hexDigitToBools('f')); + try { + Conversion.hexDigitToBools('G'); + fail("Thrown " + IllegalArgumentException.class.getName() + " expected"); + } catch (final IllegalArgumentException e) { + // OK + } } /** @@ -190,6 +208,12 @@ public class ConversionTest { new boolean[]{true, true, true, true}, Conversion.hexDigitM0ToBools('F')); assertBoolArrayEquals( new boolean[]{true, true, true, true}, Conversion.hexDigitM0ToBools('f')); + try { + Conversion.hexDigitM0ToBools('G'); + fail("Thrown " + IllegalArgumentException.class.getName() + " expected"); + } catch (final IllegalArgumentException e) { + // OK + } } /** @@ -207,12 +231,20 @@ public class ConversionTest { assertEquals('7', Conversion.boolsToHexDigit(new boolean[]{true, true, true, false})); assertEquals('8', Conversion.boolsToHexDigit(new boolean[]{false, false, false, true})); assertEquals('9', Conversion.boolsToHexDigit(new boolean[]{true, false, false, true})); - assertEquals('A', Conversion.boolsToHexDigit(new boolean[]{false, true, false, true})); - assertEquals('B', Conversion.boolsToHexDigit(new boolean[]{true, true, false, true})); - assertEquals('C', Conversion.boolsToHexDigit(new boolean[]{false, false, true, true})); - assertEquals('D', Conversion.boolsToHexDigit(new boolean[]{true, false, true, true})); - assertEquals('E', Conversion.boolsToHexDigit(new boolean[]{false, true, true, true})); - assertEquals('F', Conversion.boolsToHexDigit(new boolean[]{true, true, true, true})); + assertEquals('a', Conversion.boolsToHexDigit(new boolean[]{false, true, false, true})); + assertEquals('b', Conversion.boolsToHexDigit(new boolean[]{true, true, false, true})); + assertEquals('c', Conversion.boolsToHexDigit(new boolean[]{false, false, true, true})); + assertEquals('d', Conversion.boolsToHexDigit(new boolean[]{true, false, true, true})); + assertEquals('e', Conversion.boolsToHexDigit(new boolean[]{false, true, true, true})); + assertEquals('f', Conversion.boolsToHexDigit(new boolean[]{true, true, true, true})); + assertEquals('1', Conversion.boolsToHexDigit(new boolean[]{true})); + assertEquals('f', Conversion.boolsToHexDigit(new boolean[]{true, true, true, true, true})); + try { + assertEquals('0', Conversion.boolsToHexDigit(new boolean[]{})); + fail("Thrown " + ArrayIndexOutOfBoundsException.class.getName() + " expected"); + } catch (final ArrayIndexOutOfBoundsException e) { + // OK + } } /** @@ -228,7 +260,7 @@ public class ConversionTest { assertEquals('5', Conversion.boolsToHexDigit(longArray, 0)); assertEquals('2', Conversion.boolsToHexDigit(longArray, 1)); assertEquals('9', Conversion.boolsToHexDigit(longArray, 2)); - assertEquals('C', Conversion.boolsToHexDigit(longArray, 3)); + assertEquals('c', Conversion.boolsToHexDigit(longArray, 3)); assertEquals('6', Conversion.boolsToHexDigit(longArray, 4)); assertEquals('3', Conversion.boolsToHexDigit(longArray, 5)); assertEquals('1', Conversion.boolsToHexDigit(longArray, 6)); @@ -260,17 +292,17 @@ public class ConversionTest { assertEquals( '9', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, false, false, true})); assertEquals( - 'A', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, false, true, false})); + 'a', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, false, true, false})); assertEquals( - 'B', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, false, true, true})); + 'b', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, false, true, true})); assertEquals( - 'C', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, true, false, false})); + 'c', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, true, false, false})); assertEquals( - 'D', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, true, false, true})); + 'd', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, true, false, true})); assertEquals( - 'E', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, true, true, false})); + 'e', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, true, true, false})); assertEquals( - 'F', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, true, true, true})); + 'f', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, true, true, true})); } /** @@ -283,9 +315,9 @@ public class ConversionTest { // assertEquals('3', Conversion.boolsToHexDigitM0(shortArray,1)); // assertEquals('1', Conversion.boolsToHexDigitM0(shortArray,2)); boolean[] shortArray = new boolean[]{true, true, false, true}; - assertEquals('D', Conversion.boolsToHexDigitM0_4bits(shortArray, 0)); + assertEquals('d', Conversion.boolsToHexDigitM0_4bits(shortArray, 0)); boolean[] longArray = new boolean[]{true, false, true, false, false, true, true}; - assertEquals('A', Conversion.boolsToHexDigitM0_4bits(longArray, 0)); + assertEquals('a', Conversion.boolsToHexDigitM0_4bits(longArray, 0)); assertEquals('4', Conversion.boolsToHexDigitM0_4bits(longArray, 1)); assertEquals('9', Conversion.boolsToHexDigitM0_4bits(longArray, 2)); assertEquals('3', Conversion.boolsToHexDigitM0_4bits(longArray, 3)); @@ -294,7 +326,7 @@ public class ConversionTest { // assertEquals('1', Conversion.boolsToHexDigitM0(longArray,6)); boolean[] maxLengthArray = new boolean[]{ true, false, true, false, false, true, true, true}; - assertEquals('A', Conversion.boolsToHexDigitM0_4bits(maxLengthArray, 0)); + assertEquals('a', Conversion.boolsToHexDigitM0_4bits(maxLengthArray, 0)); assertEquals('4', Conversion.boolsToHexDigitM0_4bits(maxLengthArray, 1)); assertEquals('9', Conversion.boolsToHexDigitM0_4bits(maxLengthArray, 2)); assertEquals('3', Conversion.boolsToHexDigitM0_4bits(maxLengthArray, 3)); @@ -304,7 +336,7 @@ public class ConversionTest { // assertEquals('1', Conversion.boolsToHexDigitM0(longArray,7)); boolean[] javaDocCheck = new boolean[]{ true, false, false, true, true, false, true, false}; - assertEquals('D', Conversion.boolsToHexDigitM0_4bits(javaDocCheck, 3)); + assertEquals('d', Conversion.boolsToHexDigitM0_4bits(javaDocCheck, 3)); } @@ -334,16 +366,16 @@ public class ConversionTest { assertEquals( '9', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, false, false, true})); assertEquals( - 'A', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, false, true, false})); + 'a', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, false, true, false})); assertEquals( - 'B', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, false, true, true})); + 'b', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, false, true, true})); assertEquals( - 'C', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, true, false, false})); + 'c', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, true, false, false})); assertEquals( - 'D', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, true, false, true})); + 'd', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, true, false, true})); assertEquals( - 'E', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, true, true, false})); - assertEquals('F', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, true, true, true})); + 'e', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, true, true, false})); + assertEquals('f', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, true, true, true})); assertEquals( '4', Conversion.boolsBeM0ToHexDigit(new boolean[]{ @@ -370,8 +402,8 @@ public class ConversionTest { assertEquals('5', Conversion.boolsBeM0ToHexDigit(shortArray2, 0)); assertEquals('2', Conversion.boolsBeM0ToHexDigit(shortArray2, 1)); assertEquals('9', Conversion.boolsBeM0ToHexDigit(shortArray2, 2)); - assertEquals('C', Conversion.boolsBeM0ToHexDigit(shortArray2, 3)); - assertEquals('E', Conversion.boolsBeM0ToHexDigit(shortArray2, 4)); + assertEquals('c', Conversion.boolsBeM0ToHexDigit(shortArray2, 3)); + assertEquals('e', Conversion.boolsBeM0ToHexDigit(shortArray2, 4)); assertEquals('7', Conversion.boolsBeM0ToHexDigit(shortArray2, 5)); assertEquals('3', Conversion.boolsBeM0ToHexDigit(shortArray2, 6)); assertEquals('1', Conversion.boolsBeM0ToHexDigit(shortArray2, 7)); @@ -381,17 +413,17 @@ public class ConversionTest { assertEquals('5', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 0)); assertEquals('2', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 1)); assertEquals('9', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 2)); - assertEquals('C', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 3)); - assertEquals('E', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 4)); + assertEquals('c', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 3)); + assertEquals('e', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 4)); assertEquals('7', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 5)); - assertEquals('B', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 6)); + assertEquals('b', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 6)); assertEquals('5', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 7)); - assertEquals('A', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 8)); + assertEquals('a', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 8)); assertEquals('5', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 9)); assertEquals('2', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 10)); assertEquals('9', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 11)); - assertEquals('C', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 12)); + assertEquals('c', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 12)); assertEquals('6', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 13)); assertEquals('3', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 14)); assertEquals('1', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 15)); @@ -413,12 +445,18 @@ public class ConversionTest { assertEquals('7', Conversion.intToHexDigit(7)); assertEquals('8', Conversion.intToHexDigit(8)); assertEquals('9', Conversion.intToHexDigit(9)); - assertEquals('A', Conversion.intToHexDigit(10)); - assertEquals('B', Conversion.intToHexDigit(11)); - assertEquals('C', Conversion.intToHexDigit(12)); - assertEquals('D', Conversion.intToHexDigit(13)); - assertEquals('E', Conversion.intToHexDigit(14)); - assertEquals('F', Conversion.intToHexDigit(15)); + assertEquals('a', Conversion.intToHexDigit(10)); + assertEquals('b', Conversion.intToHexDigit(11)); + assertEquals('c', Conversion.intToHexDigit(12)); + assertEquals('d', Conversion.intToHexDigit(13)); + assertEquals('e', Conversion.intToHexDigit(14)); + assertEquals('f', Conversion.intToHexDigit(15)); + try { + Conversion.intToHexDigit(16); + fail("Thrown " + IllegalArgumentException.class.getName() + " expected"); + } catch (final IllegalArgumentException e) { + // OK + } } /** @@ -429,19 +467,25 @@ public class ConversionTest { assertEquals('0', Conversion.intToHexDigitM0(0)); assertEquals('8', Conversion.intToHexDigitM0(1)); assertEquals('4', Conversion.intToHexDigitM0(2)); - assertEquals('C', Conversion.intToHexDigitM0(3)); + assertEquals('c', Conversion.intToHexDigitM0(3)); assertEquals('2', Conversion.intToHexDigitM0(4)); - assertEquals('A', Conversion.intToHexDigitM0(5)); + assertEquals('a', Conversion.intToHexDigitM0(5)); assertEquals('6', Conversion.intToHexDigitM0(6)); - assertEquals('E', Conversion.intToHexDigitM0(7)); + assertEquals('e', Conversion.intToHexDigitM0(7)); assertEquals('1', Conversion.intToHexDigitM0(8)); assertEquals('9', Conversion.intToHexDigitM0(9)); assertEquals('5', Conversion.intToHexDigitM0(10)); - assertEquals('D', Conversion.intToHexDigitM0(11)); + assertEquals('d', Conversion.intToHexDigitM0(11)); assertEquals('3', Conversion.intToHexDigitM0(12)); - assertEquals('B', Conversion.intToHexDigitM0(13)); + assertEquals('b', Conversion.intToHexDigitM0(13)); assertEquals('7', Conversion.intToHexDigitM0(14)); - assertEquals('F', Conversion.intToHexDigitM0(15)); + assertEquals('f', Conversion.intToHexDigitM0(15)); + try { + Conversion.intToHexDigitM0(16); + fail("Thrown " + IllegalArgumentException.class.getName() + " expected"); + } catch (final IllegalArgumentException e) { + // OK + } } static String dbgPrint(boolean[] src) { @@ -1159,52 +1203,52 @@ public class ConversionTest { assertEquals("", Conversion.longToHexs(0x0000000000000000L, 100, "", 0, 0)); assertEquals("", Conversion.longToHexs(0x0000000000000000L, 0, "", 100, 0)); assertEquals( - "FFFFFFFFFFFFFFFFFFFFFFFF", - Conversion.longToHexs(0x1234567890ABCDEFL, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 0)); + "ffffffffffffffffffffffff", + Conversion.longToHexs(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 0, 0)); assertEquals( - "3FFFFFFFFFFFFFFFFFFFFFFF", - Conversion.longToHexs(0x1234567890ABCDE3L, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 1)); + "3fffffffffffffffffffffff", + Conversion.longToHexs(0x1234567890ABCDE3L, 0, "ffffffffffffffffffffffff", 0, 1)); assertEquals( - "FEFFFFFFFFFFFFFFFFFFFFFF", - Conversion.longToHexs(0x1234567890ABCDEFL, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 2)); + "feffffffffffffffffffffff", + Conversion.longToHexs(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 0, 2)); assertEquals( - "FEDCFFFFFFFFFFFFFFFFFFFF", - Conversion.longToHexs(0x1234567890ABCDEFL, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 4)); + "fedcffffffffffffffffffff", + Conversion.longToHexs(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 0, 4)); assertEquals( - "FEDCBA098765432FFFFFFFFF", - Conversion.longToHexs(0x1234567890ABCDEFL, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 15)); + "fedcba098765432fffffffff", + Conversion.longToHexs(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 0, 15)); assertEquals( - "FEDCBA0987654321FFFFFFFF", - Conversion.longToHexs(0x1234567890ABCDEFL, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 16)); + "fedcba0987654321ffffffff", + Conversion.longToHexs(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 0, 16)); assertEquals( - "FFF3FFFFFFFFFFFFFFFFFFFF", - Conversion.longToHexs(0x1234567890ABCDE3L, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 1)); + "fff3ffffffffffffffffffff", + Conversion.longToHexs(0x1234567890ABCDE3L, 0, "ffffffffffffffffffffffff", 3, 1)); assertEquals( - "FFFFEFFFFFFFFFFFFFFFFFFF", - Conversion.longToHexs(0x1234567890ABCDEFL, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 2)); + "ffffefffffffffffffffffff", + Conversion.longToHexs(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 3, 2)); assertEquals( - "FFFFEDCFFFFFFFFFFFFFFFFF", - Conversion.longToHexs(0x1234567890ABCDEFL, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 4)); + "ffffedcfffffffffffffffff", + Conversion.longToHexs(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 3, 4)); assertEquals( - "FFFFEDCBA098765432FFFFFF", - Conversion.longToHexs(0x1234567890ABCDEFL, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 15)); + "ffffedcba098765432ffffff", + Conversion.longToHexs(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 3, 15)); assertEquals( - "FFFFEDCBA0987654321FFFFF", - Conversion.longToHexs(0x1234567890ABCDEFL, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 16)); + "ffffedcba0987654321fffff", + Conversion.longToHexs(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 3, 16)); assertEquals( - "7FFFFFFFFFFFFFFFFFFFFFFF", - Conversion.longToHexs(0x1234567890ABCDEFL, 1, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 1)); + "7fffffffffffffffffffffff", + Conversion.longToHexs(0x1234567890ABCDEFL, 1, "ffffffffffffffffffffffff", 0, 1)); assertEquals( - "BFFFFFFFFFFFFFFFFFFFFFFF", - Conversion.longToHexs(0x1234567890ABCDEFL, 2, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 1)); + "bfffffffffffffffffffffff", + Conversion.longToHexs(0x1234567890ABCDEFL, 2, "ffffffffffffffffffffffff", 0, 1)); assertEquals( - "FFFDB975121FCA86420FFFFF", - Conversion.longToHexs(0x1234567890ABCDEFL, 3, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 16)); - // assertEquals("FFFFFFFFFFFFFFFFFFFFFFFF",Conversion.longToHexs(0x1234567890ABCDEFL,4,"FFFFFFFFFFFFFFFFFFFFFFFF",3,16));//rejected + "fffdb975121fca86420fffff", + Conversion.longToHexs(0x1234567890ABCDEFL, 3, "ffffffffffffffffffffffff", 3, 16)); + // assertEquals("ffffffffffffffffffffffff",Conversion.longToHexs(0x1234567890ABCDEFL,4,"ffffffffffffffffffffffff",3,16));//rejected // by assertion assertEquals( - "FFFEDCBA0987654321FFFFFF", - Conversion.longToHexs(0x1234567890ABCDEFL, 4, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 15)); + "fffedcba0987654321ffffff", + Conversion.longToHexs(0x1234567890ABCDEFL, 4, "ffffffffffffffffffffffff", 3, 15)); } /** @@ -1216,52 +1260,52 @@ public class ConversionTest { assertEquals("", Conversion.intToHexs(0x00000000, 100, "", 0, 0)); assertEquals("", Conversion.intToHexs(0x00000000, 0, "", 100, 0)); assertEquals( - "FFFFFFFFFFFFFFFFFFFFFFFF", - Conversion.intToHexs(0x90ABCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 0)); + "ffffffffffffffffffffffff", + Conversion.intToHexs(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 0, 0)); assertEquals( - "3FFFFFFFFFFFFFFFFFFFFFFF", - Conversion.intToHexs(0x90ABCDE3, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 1)); + "3fffffffffffffffffffffff", + Conversion.intToHexs(0x90ABCDE3, 0, "ffffffffffffffffffffffff", 0, 1)); assertEquals( - "FEFFFFFFFFFFFFFFFFFFFFFF", - Conversion.intToHexs(0x90ABCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 2)); + "feffffffffffffffffffffff", + Conversion.intToHexs(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 0, 2)); assertEquals( - "FEDCFFFFFFFFFFFFFFFFFFFF", - Conversion.intToHexs(0x90ABCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 4)); + "fedcffffffffffffffffffff", + Conversion.intToHexs(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 0, 4)); assertEquals( - "FEDCBA0FFFFFFFFFFFFFFFFF", - Conversion.intToHexs(0x90ABCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 7)); + "fedcba0fffffffffffffffff", + Conversion.intToHexs(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 0, 7)); assertEquals( - "FEDCBA09FFFFFFFFFFFFFFFF", - Conversion.intToHexs(0x90ABCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 8)); + "fedcba09ffffffffffffffff", + Conversion.intToHexs(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 0, 8)); assertEquals( - "FFF3FFFFFFFFFFFFFFFFFFFF", - Conversion.intToHexs(0x90ABCDE3, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 1)); + "fff3ffffffffffffffffffff", + Conversion.intToHexs(0x90ABCDE3, 0, "ffffffffffffffffffffffff", 3, 1)); assertEquals( - "FFFFEFFFFFFFFFFFFFFFFFFF", - Conversion.intToHexs(0x90ABCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 2)); + "ffffefffffffffffffffffff", + Conversion.intToHexs(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 3, 2)); assertEquals( - "FFFFEDCFFFFFFFFFFFFFFFFF", - Conversion.intToHexs(0x90ABCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 4)); + "ffffedcfffffffffffffffff", + Conversion.intToHexs(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 3, 4)); assertEquals( - "FFFFEDCBA0FFFFFFFFFFFFFF", - Conversion.intToHexs(0x90ABCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 7)); + "ffffedcba0ffffffffffffff", + Conversion.intToHexs(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 3, 7)); assertEquals( - "FFFFEDCBA09FFFFFFFFFFFFF", - Conversion.intToHexs(0x90ABCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 8)); + "ffffedcba09fffffffffffff", + Conversion.intToHexs(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 3, 8)); assertEquals( - "7FFFFFFFFFFFFFFFFFFFFFFF", - Conversion.intToHexs(0x90ABCDEF, 1, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 1)); + "7fffffffffffffffffffffff", + Conversion.intToHexs(0x90ABCDEF, 1, "ffffffffffffffffffffffff", 0, 1)); assertEquals( - "BFFFFFFFFFFFFFFFFFFFFFFF", - Conversion.intToHexs(0x90ABCDEF, 2, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 1)); + "bfffffffffffffffffffffff", + Conversion.intToHexs(0x90ABCDEF, 2, "ffffffffffffffffffffffff", 0, 1)); assertEquals( - "FFFDB97512FFFFFFFFFFFFFF", - Conversion.intToHexs(0x90ABCDEF, 3, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 8)); - // assertEquals("FFFFFFFFFFFFFFFFFFFFFFFF",Conversion.intToHexs(0x90ABCDEF, - // 4,"FFFFFFFFFFFFFFFFFFFFFFFF",3,8));//rejected by assertion + "fffdb97512ffffffffffffff", + Conversion.intToHexs(0x90ABCDEF, 3, "ffffffffffffffffffffffff", 3, 8)); + // assertEquals("ffffffffffffffffffffffff",Conversion.intToHexs(0x90ABCDEF, + // 4,"ffffffffffffffffffffffff",3,8));//rejected by assertion assertEquals( - "FFFEDCBA09FFFFFFFFFFFFFF", - Conversion.intToHexs(0x90ABCDEF, 4, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 7)); + "fffedcba09ffffffffffffff", + Conversion.intToHexs(0x90ABCDEF, 4, "ffffffffffffffffffffffff", 3, 7)); } /** @@ -1273,40 +1317,40 @@ public class ConversionTest { assertEquals("", Conversion.shortToHexs((short)0x0000, 100, "", 0, 0)); assertEquals("", Conversion.shortToHexs((short)0x0000, 0, "", 100, 0)); assertEquals( - "FFFFFFFFFFFFFFFFFFFFFFFF", - Conversion.shortToHexs((short)0xCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 0)); + "ffffffffffffffffffffffff", + Conversion.shortToHexs((short)0xCDEF, 0, "ffffffffffffffffffffffff", 0, 0)); assertEquals( - "3FFFFFFFFFFFFFFFFFFFFFFF", - Conversion.shortToHexs((short)0xCDE3, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 1)); + "3fffffffffffffffffffffff", + Conversion.shortToHexs((short)0xCDE3, 0, "ffffffffffffffffffffffff", 0, 1)); assertEquals( - "FEFFFFFFFFFFFFFFFFFFFFFF", - Conversion.shortToHexs((short)0xCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 2)); + "feffffffffffffffffffffff", + Conversion.shortToHexs((short)0xCDEF, 0, "ffffffffffffffffffffffff", 0, 2)); assertEquals( - "FEDFFFFFFFFFFFFFFFFFFFFF", - Conversion.shortToHexs((short)0xCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 3)); + "fedfffffffffffffffffffff", + Conversion.shortToHexs((short)0xCDEF, 0, "ffffffffffffffffffffffff", 0, 3)); assertEquals( - "FEDCFFFFFFFFFFFFFFFFFFFF", - Conversion.shortToHexs((short)0xCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 4)); + "fedcffffffffffffffffffff", + Conversion.shortToHexs((short)0xCDEF, 0, "ffffffffffffffffffffffff", 0, 4)); assertEquals( - "FFF3FFFFFFFFFFFFFFFFFFFF", - Conversion.shortToHexs((short)0xCDE3, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 1)); + "fff3ffffffffffffffffffff", + Conversion.shortToHexs((short)0xCDE3, 0, "ffffffffffffffffffffffff", 3, 1)); assertEquals( - "FFFFEFFFFFFFFFFFFFFFFFFF", - Conversion.shortToHexs((short)0xCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 2)); + "ffffefffffffffffffffffff", + Conversion.shortToHexs((short)0xCDEF, 0, "ffffffffffffffffffffffff", 3, 2)); assertEquals( - "7FFFFFFFFFFFFFFFFFFFFFFF", - Conversion.shortToHexs((short)0xCDEF, 1, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 1)); + "7fffffffffffffffffffffff", + Conversion.shortToHexs((short)0xCDEF, 1, "ffffffffffffffffffffffff", 0, 1)); assertEquals( - "BFFFFFFFFFFFFFFFFFFFFFFF", - Conversion.shortToHexs((short)0xCDEF, 2, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 1)); + "bfffffffffffffffffffffff", + Conversion.shortToHexs((short)0xCDEF, 2, "ffffffffffffffffffffffff", 0, 1)); assertEquals( - "FFFDB9FFFFFFFFFFFFFFFFFF", - Conversion.shortToHexs((short)0xCDEF, 3, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 4)); - // assertEquals("FFFFFFFFFFFFFFFFFFFFFFFF",Conversion.shortToHexs((short)0xCDEF, - // 4,"FFFFFFFFFFFFFFFFFFFFFFFF",3,4));//rejected by assertion + "fffdb9ffffffffffffffffff", + Conversion.shortToHexs((short)0xCDEF, 3, "ffffffffffffffffffffffff", 3, 4)); + // assertEquals("ffffffffffffffffffffffff",Conversion.shortToHexs((short)0xCDEF, + // 4,"ffffffffffffffffffffffff",3,4));//rejected by assertion assertEquals( - "FFFEDCFFFFFFFFFFFFFFFFFF", - Conversion.shortToHexs((short)0xCDEF, 4, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 3)); + "fffedcffffffffffffffffff", + Conversion.shortToHexs((short)0xCDEF, 4, "ffffffffffffffffffffffff", 3, 3)); } /** @@ -1318,16 +1362,16 @@ public class ConversionTest { assertEquals("", Conversion.byteToHexs((byte)0x00, 100, "", 0, 0)); assertEquals("", Conversion.byteToHexs((byte)0x00, 0, "", 100, 0)); assertEquals("00000", Conversion.byteToHexs((byte)0xEF, 0, "00000", 0, 0)); - assertEquals("F0000", Conversion.byteToHexs((byte)0xEF, 0, "00000", 0, 1)); - assertEquals("FE000", Conversion.byteToHexs((byte)0xEF, 0, "00000", 0, 2)); - assertEquals("000F0", Conversion.byteToHexs((byte)0xEF, 0, "00000", 3, 1)); - assertEquals("000FE", Conversion.byteToHexs((byte)0xEF, 0, "00000", 3, 2)); + assertEquals("f0000", Conversion.byteToHexs((byte)0xEF, 0, "00000", 0, 1)); + assertEquals("fe000", Conversion.byteToHexs((byte)0xEF, 0, "00000", 0, 2)); + assertEquals("000f0", Conversion.byteToHexs((byte)0xEF, 0, "00000", 3, 1)); + assertEquals("000fe", Conversion.byteToHexs((byte)0xEF, 0, "00000", 3, 2)); assertEquals("70000", Conversion.byteToHexs((byte)0xEF, 1, "00000", 0, 1)); - assertEquals("B0000", Conversion.byteToHexs((byte)0xEF, 2, "00000", 0, 1)); - assertEquals("000DF", Conversion.byteToHexs((byte)0xEF, 3, "00000", 3, 2)); + assertEquals("b0000", Conversion.byteToHexs((byte)0xEF, 2, "00000", 0, 1)); + assertEquals("000df", Conversion.byteToHexs((byte)0xEF, 3, "00000", 3, 2)); // assertEquals("00000",Conversion.byteToHexs((byte)0xEF, 4,"00000",3,2));//rejected by // assertion - assertEquals("000E0", Conversion.byteToHexs((byte)0xEF, 4, "00000", 3, 1)); + assertEquals("000e0", Conversion.byteToHexs((byte)0xEF, 4, "00000", 3, 1)); } /**