commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From joe...@apache.org
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 GMT
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 <code>hexDigit</code>
      */
     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 <code>nibble</code>
      */
     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));
     }
 
     /**



Mime
View raw message