Apache/commons-lang
1
0
Fork 0
mirror of https://github.com/apache/commons-lang.git synced 2025-02-10 12:05:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use lowercase presentation for hex values as it is done in the JDK.

Browse Source 
Use JDK functionality where available.

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/lang/trunk@1393073 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Joerg Schaible 2012-10-02 18:12:53 +00:00
parent f01111b634
commit 216411597d
2 changed files with 210 additions and 234 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

128
src/main/java/org/apache/commons/lang3/Conversion.java
View File

@ -67,50 +67,13 @@ public class Conversion {
* @return an int equals to <code>hexDigit</code> * @return an int equals to <code>hexDigit</code>
*/ */
public static int hexDigitToInt(char hexDigit) { public static int hexDigitToInt(char hexDigit) {
switch (hexDigit) { final int digit = Character.digit(hexDigit, 16);
case '0': if (digit < 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:
throw new IllegalArgumentException("Cannot interpret '" throw new IllegalArgumentException("Cannot interpret '"
+ hexDigit + hexDigit
+ "' as a hexadecimal digit"); + "' as a hexadecimal digit");
} }
return digit;
} }
/** /**
@ -318,16 +281,16 @@ public static char boolsToHexDigit(boolean[] src, int srcPos) {
if (src.length > srcPos + 3 && src[srcPos + 3]) { if (src.length > srcPos + 3 && src[srcPos + 3]) {
if (src.length > srcPos + 2 && src[srcPos + 2]) { if (src.length > srcPos + 2 && src[srcPos + 2]) {
if (src.length > srcPos + 1 && src[srcPos + 1]) { if (src.length > srcPos + 1 && src[srcPos + 1]) {
if (src[srcPos]) return 'F'; if (src[srcPos]) return 'f';
else return 'E'; else return 'e';
} else { } else {
if (src[srcPos]) return 'D'; if (src[srcPos]) return 'd';
else return 'C'; else return 'c';
} }
} else { } else {
if (src.length > srcPos + 1 && src[srcPos + 1]) { if (src.length > srcPos + 1 && src[srcPos + 1]) {
if (src[srcPos]) return 'B'; if (src[srcPos]) return 'b';
else return 'A'; else return 'a';
} else { } else {
if (src[srcPos]) return '9'; if (src[srcPos]) return '9';
else return '8'; else return '8';
@ -396,15 +359,15 @@ public static char boolsToHexDigitM0_4bits(boolean[] src, int srcPos) {
if (src[srcPos + 3]) { if (src[srcPos + 3]) {
if (src[srcPos + 2]) { if (src[srcPos + 2]) {
if (src[srcPos + 1]) { if (src[srcPos + 1]) {
if (src[srcPos]) return 'F'; if (src[srcPos]) return 'f';
else return '7'; else return '7';
} else { } else {
if (src[srcPos]) return 'B'; if (src[srcPos]) return 'b';
else return '3'; else return '3';
} }
} else { } else {
if (src[srcPos + 1]) { if (src[srcPos + 1]) {
if (src[srcPos]) return 'D'; if (src[srcPos]) return 'd';
else return '5'; else return '5';
} else { } else {
if (src[srcPos]) return '9'; if (src[srcPos]) return '9';
@ -414,15 +377,15 @@ public static char boolsToHexDigitM0_4bits(boolean[] src, int srcPos) {
} else { } else {
if (src[srcPos + 2]) { if (src[srcPos + 2]) {
if (src[srcPos + 1]) { if (src[srcPos + 1]) {
if (src[srcPos]) return 'E'; if (src[srcPos]) return 'e';
else return '6'; else return '6';
} else { } else {
if (src[srcPos]) return 'A'; if (src[srcPos]) return 'a';
else return '2'; else return '2';
} }
} else { } else {
if (src[srcPos + 1]) { if (src[srcPos + 1]) {
if (src[srcPos]) return 'C'; if (src[srcPos]) return 'c';
else return '4'; else return '4';
} else { } else {
if (src[srcPos]) return '8'; if (src[srcPos]) return '8';
@ -473,16 +436,16 @@ public static char boolsBeM0ToHexDigit(boolean[] src, int srcPos) {
if (src[srcPos]) { if (src[srcPos]) {
if (src.length > srcPos + 1 && src[srcPos + 1]) { if (src.length > srcPos + 1 && src[srcPos + 1]) {
if (src.length > srcPos + 2 && src[srcPos + 2]) { if (src.length > srcPos + 2 && src[srcPos + 2]) {
if (src.length > srcPos + 3 && src[srcPos + 3]) return 'F'; if (src.length > srcPos + 3 && src[srcPos + 3]) return 'f';
else return 'E'; else return 'e';
} else { } else {
if (src.length > srcPos + 3 && src[srcPos + 3]) return 'D'; if (src.length > srcPos + 3 && src[srcPos + 3]) return 'd';
else return 'C'; else return 'c';
} }
} else { } else {
if (src.length > srcPos + 2 && src[srcPos + 2]) { if (src.length > srcPos + 2 && src[srcPos + 2]) {
if (src.length > srcPos + 3 && src[srcPos + 3]) return 'B'; if (src.length > srcPos + 3 && src[srcPos + 3]) return 'b';
else return 'A'; else return 'a';
} else { } else {
if (src.length > srcPos + 3 && src[srcPos + 3]) return '9'; if (src.length > srcPos + 3 && src[srcPos + 3]) return '9';
else return '8'; else return '8';
@ -527,42 +490,11 @@ public static char boolsBeM0ToHexDigit(boolean[] src, int srcPos) {
* @return a hexadecimal digit representing the 4 lsb of <code>nibble</code> * @return a hexadecimal digit representing the 4 lsb of <code>nibble</code>
*/ */
public static char intToHexDigit(int nibble) { public static char intToHexDigit(int nibble) {
switch (nibble) { char c = Character.forDigit(nibble, 16);
case 0x0: if (c == Character.MIN_VALUE) {
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:
throw new IllegalArgumentException("nibble value not between 0 and 15: " + nibble); throw new IllegalArgumentException("nibble value not between 0 and 15: " + nibble);
} }
return c;
} }
/** /**
@ -591,15 +523,15 @@ public static char intToHexDigitM0(int nibble) {
case 0x2: case 0x2:
return '4'; return '4';
case 0x3: case 0x3:
return 'C'; return 'c';
case 0x4: case 0x4:
return '2'; return '2';
case 0x5: case 0x5:
return 'A'; return 'a';
case 0x6: case 0x6:
return '6'; return '6';
case 0x7: case 0x7:
return 'E'; return 'e';
case 0x8: case 0x8:
return '1'; return '1';
case 0x9: case 0x9:
@ -607,15 +539,15 @@ public static char intToHexDigitM0(int nibble) {
case 0xA: case 0xA:
return '5'; return '5';
case 0xB: case 0xB:
return 'D'; return 'd';
case 0xC: case 0xC:
return '3'; return '3';
case 0xD: case 0xD:
return 'B'; return 'b';
case 0xE: case 0xE:
return '7'; return '7';
case 0xF: case 0xF:
return 'F'; return 'f';
default: default:
throw new IllegalArgumentException("nibble value not between 0 and 15: " + nibble); throw new IllegalArgumentException("nibble value not between 0 and 15: " + nibble);
} }

316
src/test/java/org/apache/commons/lang3/ConversionTest.java
View File

@ -59,6 +59,12 @@ public void testHexDigitToInt() {
assertEquals(14, Conversion.hexDigitToInt('e')); assertEquals(14, Conversion.hexDigitToInt('e'));
assertEquals(15, Conversion.hexDigitToInt('F')); assertEquals(15, Conversion.hexDigitToInt('F'));
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 void testHexDigitM0ToInt() {
assertEquals(0x7, Conversion.hexDigitM0ToInt('e')); assertEquals(0x7, Conversion.hexDigitM0ToInt('e'));
assertEquals(0xF, Conversion.hexDigitM0ToInt('F')); assertEquals(0xF, Conversion.hexDigitM0ToInt('F'));
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 void testHexDigitToBools() {
new boolean[]{true, true, true, true}, Conversion.hexDigitToBools('F')); new boolean[]{true, true, true, true}, Conversion.hexDigitToBools('F'));
assertBoolArrayEquals( assertBoolArrayEquals(
new boolean[]{true, true, true, true}, Conversion.hexDigitToBools('f')); 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 void testHexDigitM0ToBools() {
new boolean[]{true, true, true, true}, Conversion.hexDigitM0ToBools('F')); new boolean[]{true, true, true, true}, Conversion.hexDigitM0ToBools('F'));
assertBoolArrayEquals( assertBoolArrayEquals(
new boolean[]{true, true, true, true}, Conversion.hexDigitM0ToBools('f')); 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 void testBoolsToHexDigit() {
assertEquals('7', Conversion.boolsToHexDigit(new boolean[]{true, true, true, false})); assertEquals('7', Conversion.boolsToHexDigit(new boolean[]{true, true, true, false}));
assertEquals('8', Conversion.boolsToHexDigit(new boolean[]{false, false, false, true})); assertEquals('8', Conversion.boolsToHexDigit(new boolean[]{false, false, false, true}));
assertEquals('9', Conversion.boolsToHexDigit(new boolean[]{true, false, false, true})); assertEquals('9', Conversion.boolsToHexDigit(new boolean[]{true, false, false, true}));
assertEquals('A', Conversion.boolsToHexDigit(new boolean[]{false, true, false, true})); assertEquals('a', Conversion.boolsToHexDigit(new boolean[]{false, true, false, true}));
assertEquals('B', Conversion.boolsToHexDigit(new boolean[]{true, true, false, true})); assertEquals('b', Conversion.boolsToHexDigit(new boolean[]{true, true, false, true}));
assertEquals('C', Conversion.boolsToHexDigit(new boolean[]{false, false, true, true})); assertEquals('c', Conversion.boolsToHexDigit(new boolean[]{false, false, true, true}));
assertEquals('D', Conversion.boolsToHexDigit(new boolean[]{true, false, true, true})); assertEquals('d', Conversion.boolsToHexDigit(new boolean[]{true, false, true, true}));
assertEquals('E', Conversion.boolsToHexDigit(new boolean[]{false, true, true, true})); assertEquals('e', Conversion.boolsToHexDigit(new boolean[]{false, true, true, true}));
assertEquals('F', Conversion.boolsToHexDigit(new boolean[]{true, 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 void testBoolsToHexDigit_2args() {
assertEquals('5', Conversion.boolsToHexDigit(longArray, 0)); assertEquals('5', Conversion.boolsToHexDigit(longArray, 0));
assertEquals('2', Conversion.boolsToHexDigit(longArray, 1)); assertEquals('2', Conversion.boolsToHexDigit(longArray, 1));
assertEquals('9', Conversion.boolsToHexDigit(longArray, 2)); 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('6', Conversion.boolsToHexDigit(longArray, 4));
assertEquals('3', Conversion.boolsToHexDigit(longArray, 5)); assertEquals('3', Conversion.boolsToHexDigit(longArray, 5));
assertEquals('1', Conversion.boolsToHexDigit(longArray, 6)); assertEquals('1', Conversion.boolsToHexDigit(longArray, 6));
@ -260,17 +292,17 @@ public void testBoolsToHexDigitM0_bits() {
assertEquals( assertEquals(
'9', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, false, false, true})); '9', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, false, false, true}));
assertEquals( assertEquals(
'A', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, false, true, false})); 'a', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, false, true, false}));
assertEquals( assertEquals(
'B', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, false, true, true})); 'b', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, false, true, true}));
assertEquals( assertEquals(
'C', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, true, false, false})); 'c', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, true, false, false}));
assertEquals( assertEquals(
'D', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, true, false, true})); 'd', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, true, false, true}));
assertEquals( assertEquals(
'E', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, true, true, false})); 'e', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, true, true, false}));
assertEquals( 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 void testBoolsToHexDigitM0_4bits_2args() {
// assertEquals('3', Conversion.boolsToHexDigitM0(shortArray,1)); // assertEquals('3', Conversion.boolsToHexDigitM0(shortArray,1));
// assertEquals('1', Conversion.boolsToHexDigitM0(shortArray,2)); // assertEquals('1', Conversion.boolsToHexDigitM0(shortArray,2));
boolean[] shortArray = new boolean[]{true, true, false, true}; 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}; 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('4', Conversion.boolsToHexDigitM0_4bits(longArray, 1));
assertEquals('9', Conversion.boolsToHexDigitM0_4bits(longArray, 2)); assertEquals('9', Conversion.boolsToHexDigitM0_4bits(longArray, 2));
assertEquals('3', Conversion.boolsToHexDigitM0_4bits(longArray, 3)); assertEquals('3', Conversion.boolsToHexDigitM0_4bits(longArray, 3));
@ -294,7 +326,7 @@ public void testBoolsToHexDigitM0_4bits_2args() {
// assertEquals('1', Conversion.boolsToHexDigitM0(longArray,6)); // assertEquals('1', Conversion.boolsToHexDigitM0(longArray,6));
boolean[] maxLengthArray = new boolean[]{ boolean[] maxLengthArray = new boolean[]{
true, false, true, false, false, true, true, true}; 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('4', Conversion.boolsToHexDigitM0_4bits(maxLengthArray, 1));
assertEquals('9', Conversion.boolsToHexDigitM0_4bits(maxLengthArray, 2)); assertEquals('9', Conversion.boolsToHexDigitM0_4bits(maxLengthArray, 2));
assertEquals('3', Conversion.boolsToHexDigitM0_4bits(maxLengthArray, 3)); assertEquals('3', Conversion.boolsToHexDigitM0_4bits(maxLengthArray, 3));
@ -304,7 +336,7 @@ public void testBoolsToHexDigitM0_4bits_2args() {
// assertEquals('1', Conversion.boolsToHexDigitM0(longArray,7)); // assertEquals('1', Conversion.boolsToHexDigitM0(longArray,7));
boolean[] javaDocCheck = new boolean[]{ boolean[] javaDocCheck = new boolean[]{
true, false, false, true, true, false, true, false}; 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 void testBoolsBeM0ToHexDigit() {
assertEquals( assertEquals(
'9', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, false, false, true})); '9', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, false, false, true}));
assertEquals( assertEquals(
'A', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, false, true, false})); 'a', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, false, true, false}));
assertEquals( assertEquals(
'B', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, false, true, true})); 'b', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, false, true, true}));
assertEquals( assertEquals(
'C', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, true, false, false})); 'c', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, true, false, false}));
assertEquals( assertEquals(
'D', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, true, false, true})); 'd', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, true, false, true}));
assertEquals( assertEquals(
'E', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, true, true, false})); 'e', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, true, true, false}));
assertEquals('F', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, true, true, true})); assertEquals('f', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, true, true, true}));
assertEquals( assertEquals(
'4', '4',
Conversion.boolsBeM0ToHexDigit(new boolean[]{ Conversion.boolsBeM0ToHexDigit(new boolean[]{
@ -370,8 +402,8 @@ public void testBoolsBeM0ToHexDigit_2args() {
assertEquals('5', Conversion.boolsBeM0ToHexDigit(shortArray2, 0)); assertEquals('5', Conversion.boolsBeM0ToHexDigit(shortArray2, 0));
assertEquals('2', Conversion.boolsBeM0ToHexDigit(shortArray2, 1)); assertEquals('2', Conversion.boolsBeM0ToHexDigit(shortArray2, 1));
assertEquals('9', Conversion.boolsBeM0ToHexDigit(shortArray2, 2)); assertEquals('9', Conversion.boolsBeM0ToHexDigit(shortArray2, 2));
assertEquals('C', Conversion.boolsBeM0ToHexDigit(shortArray2, 3)); assertEquals('c', Conversion.boolsBeM0ToHexDigit(shortArray2, 3));
assertEquals('E', Conversion.boolsBeM0ToHexDigit(shortArray2, 4)); assertEquals('e', Conversion.boolsBeM0ToHexDigit(shortArray2, 4));
assertEquals('7', Conversion.boolsBeM0ToHexDigit(shortArray2, 5)); assertEquals('7', Conversion.boolsBeM0ToHexDigit(shortArray2, 5));
assertEquals('3', Conversion.boolsBeM0ToHexDigit(shortArray2, 6)); assertEquals('3', Conversion.boolsBeM0ToHexDigit(shortArray2, 6));
assertEquals('1', Conversion.boolsBeM0ToHexDigit(shortArray2, 7)); assertEquals('1', Conversion.boolsBeM0ToHexDigit(shortArray2, 7));
@ -381,17 +413,17 @@ public void testBoolsBeM0ToHexDigit_2args() {
assertEquals('5', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 0)); assertEquals('5', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 0));
assertEquals('2', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 1)); assertEquals('2', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 1));
assertEquals('9', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 2)); assertEquals('9', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 2));
assertEquals('C', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 3)); assertEquals('c', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 3));
assertEquals('E', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 4)); assertEquals('e', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 4));
assertEquals('7', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 5)); 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('5', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 7));
assertEquals('A', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 8)); assertEquals('a', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 8));
assertEquals('5', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 9)); assertEquals('5', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 9));
assertEquals('2', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 10)); assertEquals('2', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 10));
assertEquals('9', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 11)); 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('6', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 13));
assertEquals('3', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 14)); assertEquals('3', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 14));
assertEquals('1', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 15)); assertEquals('1', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 15));
@ -413,12 +445,18 @@ public void testIntToHexDigit() {
assertEquals('7', Conversion.intToHexDigit(7)); assertEquals('7', Conversion.intToHexDigit(7));
assertEquals('8', Conversion.intToHexDigit(8)); assertEquals('8', Conversion.intToHexDigit(8));
assertEquals('9', Conversion.intToHexDigit(9)); assertEquals('9', Conversion.intToHexDigit(9));
assertEquals('A', Conversion.intToHexDigit(10)); assertEquals('a', Conversion.intToHexDigit(10));
assertEquals('B', Conversion.intToHexDigit(11)); assertEquals('b', Conversion.intToHexDigit(11));
assertEquals('C', Conversion.intToHexDigit(12)); assertEquals('c', Conversion.intToHexDigit(12));
assertEquals('D', Conversion.intToHexDigit(13)); assertEquals('d', Conversion.intToHexDigit(13));
assertEquals('E', Conversion.intToHexDigit(14)); assertEquals('e', Conversion.intToHexDigit(14));
assertEquals('F', Conversion.intToHexDigit(15)); 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 void testIntToHexDigitM0() {
assertEquals('0', Conversion.intToHexDigitM0(0)); assertEquals('0', Conversion.intToHexDigitM0(0));
assertEquals('8', Conversion.intToHexDigitM0(1)); assertEquals('8', Conversion.intToHexDigitM0(1));
assertEquals('4', Conversion.intToHexDigitM0(2)); assertEquals('4', Conversion.intToHexDigitM0(2));
assertEquals('C', Conversion.intToHexDigitM0(3)); assertEquals('c', Conversion.intToHexDigitM0(3));
assertEquals('2', Conversion.intToHexDigitM0(4)); assertEquals('2', Conversion.intToHexDigitM0(4));
assertEquals('A', Conversion.intToHexDigitM0(5)); assertEquals('a', Conversion.intToHexDigitM0(5));
assertEquals('6', Conversion.intToHexDigitM0(6)); assertEquals('6', Conversion.intToHexDigitM0(6));
assertEquals('E', Conversion.intToHexDigitM0(7)); assertEquals('e', Conversion.intToHexDigitM0(7));
assertEquals('1', Conversion.intToHexDigitM0(8)); assertEquals('1', Conversion.intToHexDigitM0(8));
assertEquals('9', Conversion.intToHexDigitM0(9)); assertEquals('9', Conversion.intToHexDigitM0(9));
assertEquals('5', Conversion.intToHexDigitM0(10)); assertEquals('5', Conversion.intToHexDigitM0(10));
assertEquals('D', Conversion.intToHexDigitM0(11)); assertEquals('d', Conversion.intToHexDigitM0(11));
assertEquals('3', Conversion.intToHexDigitM0(12)); assertEquals('3', Conversion.intToHexDigitM0(12));
assertEquals('B', Conversion.intToHexDigitM0(13)); assertEquals('b', Conversion.intToHexDigitM0(13));
assertEquals('7', Conversion.intToHexDigitM0(14)); 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) { static String dbgPrint(boolean[] src) {
@ -1159,52 +1203,52 @@ public void testLongToHexs() {
assertEquals("", Conversion.longToHexs(0x0000000000000000L, 100, "", 0, 0)); assertEquals("", Conversion.longToHexs(0x0000000000000000L, 100, "", 0, 0));
assertEquals("", Conversion.longToHexs(0x0000000000000000L, 0, "", 100, 0)); assertEquals("", Conversion.longToHexs(0x0000000000000000L, 0, "", 100, 0));
assertEquals( assertEquals(
"FFFFFFFFFFFFFFFFFFFFFFFF", "ffffffffffffffffffffffff",
Conversion.longToHexs(0x1234567890ABCDEFL, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 0)); Conversion.longToHexs(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 0, 0));
assertEquals( assertEquals(
"3FFFFFFFFFFFFFFFFFFFFFFF", "3fffffffffffffffffffffff",
Conversion.longToHexs(0x1234567890ABCDE3L, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 1)); Conversion.longToHexs(0x1234567890ABCDE3L, 0, "ffffffffffffffffffffffff", 0, 1));
assertEquals( assertEquals(
"FEFFFFFFFFFFFFFFFFFFFFFF", "feffffffffffffffffffffff",
Conversion.longToHexs(0x1234567890ABCDEFL, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 2)); Conversion.longToHexs(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 0, 2));
assertEquals( assertEquals(
"FEDCFFFFFFFFFFFFFFFFFFFF", "fedcffffffffffffffffffff",
Conversion.longToHexs(0x1234567890ABCDEFL, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 4)); Conversion.longToHexs(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 0, 4));
assertEquals( assertEquals(
"FEDCBA098765432FFFFFFFFF", "fedcba098765432fffffffff",
Conversion.longToHexs(0x1234567890ABCDEFL, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 15)); Conversion.longToHexs(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 0, 15));
assertEquals( assertEquals(
"FEDCBA0987654321FFFFFFFF", "fedcba0987654321ffffffff",
Conversion.longToHexs(0x1234567890ABCDEFL, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 16)); Conversion.longToHexs(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 0, 16));
assertEquals( assertEquals(
"FFF3FFFFFFFFFFFFFFFFFFFF", "fff3ffffffffffffffffffff",
Conversion.longToHexs(0x1234567890ABCDE3L, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 1)); Conversion.longToHexs(0x1234567890ABCDE3L, 0, "ffffffffffffffffffffffff", 3, 1));
assertEquals( assertEquals(
"FFFFEFFFFFFFFFFFFFFFFFFF", "ffffefffffffffffffffffff",
Conversion.longToHexs(0x1234567890ABCDEFL, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 2)); Conversion.longToHexs(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 3, 2));
assertEquals( assertEquals(
"FFFFEDCFFFFFFFFFFFFFFFFF", "ffffedcfffffffffffffffff",
Conversion.longToHexs(0x1234567890ABCDEFL, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 4)); Conversion.longToHexs(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 3, 4));
assertEquals( assertEquals(
"FFFFEDCBA098765432FFFFFF", "ffffedcba098765432ffffff",
Conversion.longToHexs(0x1234567890ABCDEFL, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 15)); Conversion.longToHexs(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 3, 15));
assertEquals( assertEquals(
"FFFFEDCBA0987654321FFFFF", "ffffedcba0987654321fffff",
Conversion.longToHexs(0x1234567890ABCDEFL, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 16)); Conversion.longToHexs(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 3, 16));
assertEquals( assertEquals(
"7FFFFFFFFFFFFFFFFFFFFFFF", "7fffffffffffffffffffffff",
Conversion.longToHexs(0x1234567890ABCDEFL, 1, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 1)); Conversion.longToHexs(0x1234567890ABCDEFL, 1, "ffffffffffffffffffffffff", 0, 1));
assertEquals( assertEquals(
"BFFFFFFFFFFFFFFFFFFFFFFF", "bfffffffffffffffffffffff",
Conversion.longToHexs(0x1234567890ABCDEFL, 2, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 1)); Conversion.longToHexs(0x1234567890ABCDEFL, 2, "ffffffffffffffffffffffff", 0, 1));
assertEquals( assertEquals(
"FFFDB975121FCA86420FFFFF", "fffdb975121fca86420fffff",
Conversion.longToHexs(0x1234567890ABCDEFL, 3, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 16)); Conversion.longToHexs(0x1234567890ABCDEFL, 3, "ffffffffffffffffffffffff", 3, 16));
// assertEquals("FFFFFFFFFFFFFFFFFFFFFFFF",Conversion.longToHexs(0x1234567890ABCDEFL,4,"FFFFFFFFFFFFFFFFFFFFFFFF",3,16));//rejected // assertEquals("ffffffffffffffffffffffff",Conversion.longToHexs(0x1234567890ABCDEFL,4,"ffffffffffffffffffffffff",3,16));//rejected
// by assertion // by assertion
assertEquals( assertEquals(
"FFFEDCBA0987654321FFFFFF", "fffedcba0987654321ffffff",
Conversion.longToHexs(0x1234567890ABCDEFL, 4, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 15)); Conversion.longToHexs(0x1234567890ABCDEFL, 4, "ffffffffffffffffffffffff", 3, 15));
} }
/** /**
@ -1216,52 +1260,52 @@ public void testIntToHexs() {
assertEquals("", Conversion.intToHexs(0x00000000, 100, "", 0, 0)); assertEquals("", Conversion.intToHexs(0x00000000, 100, "", 0, 0));
assertEquals("", Conversion.intToHexs(0x00000000, 0, "", 100, 0)); assertEquals("", Conversion.intToHexs(0x00000000, 0, "", 100, 0));
assertEquals( assertEquals(
"FFFFFFFFFFFFFFFFFFFFFFFF", "ffffffffffffffffffffffff",
Conversion.intToHexs(0x90ABCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 0)); Conversion.intToHexs(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 0, 0));
assertEquals( assertEquals(
"3FFFFFFFFFFFFFFFFFFFFFFF", "3fffffffffffffffffffffff",
Conversion.intToHexs(0x90ABCDE3, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 1)); Conversion.intToHexs(0x90ABCDE3, 0, "ffffffffffffffffffffffff", 0, 1));
assertEquals( assertEquals(
"FEFFFFFFFFFFFFFFFFFFFFFF", "feffffffffffffffffffffff",
Conversion.intToHexs(0x90ABCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 2)); Conversion.intToHexs(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 0, 2));
assertEquals( assertEquals(
"FEDCFFFFFFFFFFFFFFFFFFFF", "fedcffffffffffffffffffff",
Conversion.intToHexs(0x90ABCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 4)); Conversion.intToHexs(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 0, 4));
assertEquals( assertEquals(
"FEDCBA0FFFFFFFFFFFFFFFFF", "fedcba0fffffffffffffffff",
Conversion.intToHexs(0x90ABCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 7)); Conversion.intToHexs(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 0, 7));
assertEquals( assertEquals(
"FEDCBA09FFFFFFFFFFFFFFFF", "fedcba09ffffffffffffffff",
Conversion.intToHexs(0x90ABCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 8)); Conversion.intToHexs(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 0, 8));
assertEquals( assertEquals(
"FFF3FFFFFFFFFFFFFFFFFFFF", "fff3ffffffffffffffffffff",
Conversion.intToHexs(0x90ABCDE3, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 1)); Conversion.intToHexs(0x90ABCDE3, 0, "ffffffffffffffffffffffff", 3, 1));
assertEquals( assertEquals(
"FFFFEFFFFFFFFFFFFFFFFFFF", "ffffefffffffffffffffffff",
Conversion.intToHexs(0x90ABCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 2)); Conversion.intToHexs(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 3, 2));
assertEquals( assertEquals(
"FFFFEDCFFFFFFFFFFFFFFFFF", "ffffedcfffffffffffffffff",
Conversion.intToHexs(0x90ABCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 4)); Conversion.intToHexs(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 3, 4));
assertEquals( assertEquals(
"FFFFEDCBA0FFFFFFFFFFFFFF", "ffffedcba0ffffffffffffff",
Conversion.intToHexs(0x90ABCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 7)); Conversion.intToHexs(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 3, 7));
assertEquals( assertEquals(
"FFFFEDCBA09FFFFFFFFFFFFF", "ffffedcba09fffffffffffff",
Conversion.intToHexs(0x90ABCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 8)); Conversion.intToHexs(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 3, 8));
assertEquals( assertEquals(
"7FFFFFFFFFFFFFFFFFFFFFFF", "7fffffffffffffffffffffff",
Conversion.intToHexs(0x90ABCDEF, 1, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 1)); Conversion.intToHexs(0x90ABCDEF, 1, "ffffffffffffffffffffffff", 0, 1));
assertEquals( assertEquals(
"BFFFFFFFFFFFFFFFFFFFFFFF", "bfffffffffffffffffffffff",
Conversion.intToHexs(0x90ABCDEF, 2, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 1)); Conversion.intToHexs(0x90ABCDEF, 2, "ffffffffffffffffffffffff", 0, 1));
assertEquals( assertEquals(
"FFFDB97512FFFFFFFFFFFFFF", "fffdb97512ffffffffffffff",
Conversion.intToHexs(0x90ABCDEF, 3, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 8)); Conversion.intToHexs(0x90ABCDEF, 3, "ffffffffffffffffffffffff", 3, 8));
// assertEquals("FFFFFFFFFFFFFFFFFFFFFFFF",Conversion.intToHexs(0x90ABCDEF, // assertEquals("ffffffffffffffffffffffff",Conversion.intToHexs(0x90ABCDEF,
// 4,"FFFFFFFFFFFFFFFFFFFFFFFF",3,8));//rejected by assertion // 4,"ffffffffffffffffffffffff",3,8));//rejected by assertion
assertEquals( assertEquals(
"FFFEDCBA09FFFFFFFFFFFFFF", "fffedcba09ffffffffffffff",
Conversion.intToHexs(0x90ABCDEF, 4, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 7)); Conversion.intToHexs(0x90ABCDEF, 4, "ffffffffffffffffffffffff", 3, 7));
} }
/** /**
@ -1273,40 +1317,40 @@ public void testShortToHexs() {
assertEquals("", Conversion.shortToHexs((short)0x0000, 100, "", 0, 0)); assertEquals("", Conversion.shortToHexs((short)0x0000, 100, "", 0, 0));
assertEquals("", Conversion.shortToHexs((short)0x0000, 0, "", 100, 0)); assertEquals("", Conversion.shortToHexs((short)0x0000, 0, "", 100, 0));
assertEquals( assertEquals(
"FFFFFFFFFFFFFFFFFFFFFFFF", "ffffffffffffffffffffffff",
Conversion.shortToHexs((short)0xCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 0)); Conversion.shortToHexs((short)0xCDEF, 0, "ffffffffffffffffffffffff", 0, 0));
assertEquals( assertEquals(
"3FFFFFFFFFFFFFFFFFFFFFFF", "3fffffffffffffffffffffff",
Conversion.shortToHexs((short)0xCDE3, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 1)); Conversion.shortToHexs((short)0xCDE3, 0, "ffffffffffffffffffffffff", 0, 1));
assertEquals( assertEquals(
"FEFFFFFFFFFFFFFFFFFFFFFF", "feffffffffffffffffffffff",
Conversion.shortToHexs((short)0xCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 2)); Conversion.shortToHexs((short)0xCDEF, 0, "ffffffffffffffffffffffff", 0, 2));
assertEquals( assertEquals(
"FEDFFFFFFFFFFFFFFFFFFFFF", "fedfffffffffffffffffffff",
Conversion.shortToHexs((short)0xCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 3)); Conversion.shortToHexs((short)0xCDEF, 0, "ffffffffffffffffffffffff", 0, 3));
assertEquals( assertEquals(
"FEDCFFFFFFFFFFFFFFFFFFFF", "fedcffffffffffffffffffff",
Conversion.shortToHexs((short)0xCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 4)); Conversion.shortToHexs((short)0xCDEF, 0, "ffffffffffffffffffffffff", 0, 4));
assertEquals( assertEquals(
"FFF3FFFFFFFFFFFFFFFFFFFF", "fff3ffffffffffffffffffff",
Conversion.shortToHexs((short)0xCDE3, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 1)); Conversion.shortToHexs((short)0xCDE3, 0, "ffffffffffffffffffffffff", 3, 1));
assertEquals( assertEquals(
"FFFFEFFFFFFFFFFFFFFFFFFF", "ffffefffffffffffffffffff",
Conversion.shortToHexs((short)0xCDEF, 0, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 2)); Conversion.shortToHexs((short)0xCDEF, 0, "ffffffffffffffffffffffff", 3, 2));
assertEquals( assertEquals(
"7FFFFFFFFFFFFFFFFFFFFFFF", "7fffffffffffffffffffffff",
Conversion.shortToHexs((short)0xCDEF, 1, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 1)); Conversion.shortToHexs((short)0xCDEF, 1, "ffffffffffffffffffffffff", 0, 1));
assertEquals( assertEquals(
"BFFFFFFFFFFFFFFFFFFFFFFF", "bfffffffffffffffffffffff",
Conversion.shortToHexs((short)0xCDEF, 2, "FFFFFFFFFFFFFFFFFFFFFFFF", 0, 1)); Conversion.shortToHexs((short)0xCDEF, 2, "ffffffffffffffffffffffff", 0, 1));
assertEquals( assertEquals(
"FFFDB9FFFFFFFFFFFFFFFFFF", "fffdb9ffffffffffffffffff",
Conversion.shortToHexs((short)0xCDEF, 3, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 4)); Conversion.shortToHexs((short)0xCDEF, 3, "ffffffffffffffffffffffff", 3, 4));
// assertEquals("FFFFFFFFFFFFFFFFFFFFFFFF",Conversion.shortToHexs((short)0xCDEF, // assertEquals("ffffffffffffffffffffffff",Conversion.shortToHexs((short)0xCDEF,
// 4,"FFFFFFFFFFFFFFFFFFFFFFFF",3,4));//rejected by assertion // 4,"ffffffffffffffffffffffff",3,4));//rejected by assertion
assertEquals( assertEquals(
"FFFEDCFFFFFFFFFFFFFFFFFF", "fffedcffffffffffffffffff",
Conversion.shortToHexs((short)0xCDEF, 4, "FFFFFFFFFFFFFFFFFFFFFFFF", 3, 3)); Conversion.shortToHexs((short)0xCDEF, 4, "ffffffffffffffffffffffff", 3, 3));
} }
/** /**
@ -1318,16 +1362,16 @@ public void testByteToHexs() {
assertEquals("", Conversion.byteToHexs((byte)0x00, 100, "", 0, 0)); assertEquals("", Conversion.byteToHexs((byte)0x00, 100, "", 0, 0));
assertEquals("", Conversion.byteToHexs((byte)0x00, 0, "", 100, 0)); assertEquals("", Conversion.byteToHexs((byte)0x00, 0, "", 100, 0));
assertEquals("00000", Conversion.byteToHexs((byte)0xEF, 0, "00000", 0, 0)); assertEquals("00000", Conversion.byteToHexs((byte)0xEF, 0, "00000", 0, 0));
assertEquals("F0000", Conversion.byteToHexs((byte)0xEF, 0, "00000", 0, 1)); assertEquals("f0000", Conversion.byteToHexs((byte)0xEF, 0, "00000", 0, 1));
assertEquals("FE000", Conversion.byteToHexs((byte)0xEF, 0, "00000", 0, 2)); assertEquals("fe000", Conversion.byteToHexs((byte)0xEF, 0, "00000", 0, 2));
assertEquals("000F0", Conversion.byteToHexs((byte)0xEF, 0, "00000", 3, 1)); assertEquals("000f0", Conversion.byteToHexs((byte)0xEF, 0, "00000", 3, 1));
assertEquals("000FE", Conversion.byteToHexs((byte)0xEF, 0, "00000", 3, 2)); assertEquals("000fe", Conversion.byteToHexs((byte)0xEF, 0, "00000", 3, 2));
assertEquals("70000", Conversion.byteToHexs((byte)0xEF, 1, "00000", 0, 1)); assertEquals("70000", Conversion.byteToHexs((byte)0xEF, 1, "00000", 0, 1));
assertEquals("B0000", Conversion.byteToHexs((byte)0xEF, 2, "00000", 0, 1)); assertEquals("b0000", Conversion.byteToHexs((byte)0xEF, 2, "00000", 0, 1));
assertEquals("000DF", Conversion.byteToHexs((byte)0xEF, 3, "00000", 3, 2)); assertEquals("000df", Conversion.byteToHexs((byte)0xEF, 3, "00000", 3, 2));
// assertEquals("00000",Conversion.byteToHexs((byte)0xEF, 4,"00000",3,2));//rejected by // assertEquals("00000",Conversion.byteToHexs((byte)0xEF, 4,"00000",3,2));//rejected by
// assertion // assertion
assertEquals("000E0", Conversion.byteToHexs((byte)0xEF, 4, "00000", 3, 1)); assertEquals("000e0", Conversion.byteToHexs((byte)0xEF, 4, "00000", 3, 1));
} }
/** /**