You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by jo...@apache.org on 2012/10/04 00:05:11 UTC
svn commit: r1393792 [2/2] - in /commons/proper/lang/trunk/src:
main/java/org/apache/commons/lang3/Conversion.java
test/java/org/apache/commons/lang3/ConversionTest.java
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=1393792&r1=1393791&r2=1393792&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 Wed Oct 3 22:05:11 2012
@@ -70,34 +70,34 @@ public class ConversionTest {
}
/**
- * Tests {@link Conversion#hexDigitM0ToInt(char)}.
+ * Tests {@link Conversion#hexDigitMsb0ToInt(char)}.
*/
@Test
- public void testHexDigitM0ToInt() {
- assertEquals(0x0, Conversion.hexDigitM0ToInt('0'));
- assertEquals(0x8, Conversion.hexDigitM0ToInt('1'));
- assertEquals(0x4, Conversion.hexDigitM0ToInt('2'));
- assertEquals(0xC, Conversion.hexDigitM0ToInt('3'));
- assertEquals(0x2, Conversion.hexDigitM0ToInt('4'));
- assertEquals(0xA, Conversion.hexDigitM0ToInt('5'));
- assertEquals(0x6, Conversion.hexDigitM0ToInt('6'));
- assertEquals(0xE, Conversion.hexDigitM0ToInt('7'));
- assertEquals(0x1, Conversion.hexDigitM0ToInt('8'));
- assertEquals(0x9, Conversion.hexDigitM0ToInt('9'));
- assertEquals(0x5, Conversion.hexDigitM0ToInt('A'));
- assertEquals(0x5, Conversion.hexDigitM0ToInt('a'));
- assertEquals(0xD, Conversion.hexDigitM0ToInt('B'));
- assertEquals(0xD, Conversion.hexDigitM0ToInt('b'));
- assertEquals(0x3, Conversion.hexDigitM0ToInt('C'));
- assertEquals(0x3, Conversion.hexDigitM0ToInt('c'));
- assertEquals(0xB, Conversion.hexDigitM0ToInt('D'));
- assertEquals(0xB, Conversion.hexDigitM0ToInt('d'));
- assertEquals(0x7, Conversion.hexDigitM0ToInt('E'));
- assertEquals(0x7, Conversion.hexDigitM0ToInt('e'));
- assertEquals(0xF, Conversion.hexDigitM0ToInt('F'));
- assertEquals(0xF, Conversion.hexDigitM0ToInt('f'));
+ public void testHexDigitMsb0ToInt() {
+ assertEquals(0x0, Conversion.hexDigitMsb0ToInt('0'));
+ assertEquals(0x8, Conversion.hexDigitMsb0ToInt('1'));
+ assertEquals(0x4, Conversion.hexDigitMsb0ToInt('2'));
+ assertEquals(0xC, Conversion.hexDigitMsb0ToInt('3'));
+ assertEquals(0x2, Conversion.hexDigitMsb0ToInt('4'));
+ assertEquals(0xA, Conversion.hexDigitMsb0ToInt('5'));
+ assertEquals(0x6, Conversion.hexDigitMsb0ToInt('6'));
+ assertEquals(0xE, Conversion.hexDigitMsb0ToInt('7'));
+ assertEquals(0x1, Conversion.hexDigitMsb0ToInt('8'));
+ assertEquals(0x9, Conversion.hexDigitMsb0ToInt('9'));
+ assertEquals(0x5, Conversion.hexDigitMsb0ToInt('A'));
+ assertEquals(0x5, Conversion.hexDigitMsb0ToInt('a'));
+ assertEquals(0xD, Conversion.hexDigitMsb0ToInt('B'));
+ assertEquals(0xD, Conversion.hexDigitMsb0ToInt('b'));
+ assertEquals(0x3, Conversion.hexDigitMsb0ToInt('C'));
+ assertEquals(0x3, Conversion.hexDigitMsb0ToInt('c'));
+ assertEquals(0xB, Conversion.hexDigitMsb0ToInt('D'));
+ assertEquals(0xB, Conversion.hexDigitMsb0ToInt('d'));
+ assertEquals(0x7, Conversion.hexDigitMsb0ToInt('E'));
+ assertEquals(0x7, Conversion.hexDigitMsb0ToInt('e'));
+ assertEquals(0xF, Conversion.hexDigitMsb0ToInt('F'));
+ assertEquals(0xF, Conversion.hexDigitMsb0ToInt('f'));
try {
- Conversion.hexDigitM0ToInt('G');
+ Conversion.hexDigitMsb0ToInt('G');
fail("Thrown " + IllegalArgumentException.class.getName() + " expected");
} catch (final IllegalArgumentException e) {
// OK
@@ -105,56 +105,56 @@ public class ConversionTest {
}
/**
- * Tests {@link Conversion#hexDigitToBools(char)}.
+ * Tests {@link Conversion#hexDigitToBoolArray(char)}.
*/
@Test
- public void testHexDigitToBools() {
+ public void testHexDigitToBoolArray() {
assertBoolArrayEquals(
- new boolean[]{false, false, false, false}, Conversion.hexDigitToBools('0'));
+ new boolean[]{false, false, false, false}, Conversion.hexDigitToBoolArray('0'));
assertBoolArrayEquals(
- new boolean[]{true, false, false, false}, Conversion.hexDigitToBools('1'));
+ new boolean[]{true, false, false, false}, Conversion.hexDigitToBoolArray('1'));
assertBoolArrayEquals(
- new boolean[]{false, true, false, false}, Conversion.hexDigitToBools('2'));
+ new boolean[]{false, true, false, false}, Conversion.hexDigitToBoolArray('2'));
assertBoolArrayEquals(
- new boolean[]{true, true, false, false}, Conversion.hexDigitToBools('3'));
+ new boolean[]{true, true, false, false}, Conversion.hexDigitToBoolArray('3'));
assertBoolArrayEquals(
- new boolean[]{false, false, true, false}, Conversion.hexDigitToBools('4'));
+ new boolean[]{false, false, true, false}, Conversion.hexDigitToBoolArray('4'));
assertBoolArrayEquals(
- new boolean[]{true, false, true, false}, Conversion.hexDigitToBools('5'));
+ new boolean[]{true, false, true, false}, Conversion.hexDigitToBoolArray('5'));
assertBoolArrayEquals(
- new boolean[]{false, true, true, false}, Conversion.hexDigitToBools('6'));
+ new boolean[]{false, true, true, false}, Conversion.hexDigitToBoolArray('6'));
assertBoolArrayEquals(
- new boolean[]{true, true, true, false}, Conversion.hexDigitToBools('7'));
+ new boolean[]{true, true, true, false}, Conversion.hexDigitToBoolArray('7'));
assertBoolArrayEquals(
- new boolean[]{false, false, false, true}, Conversion.hexDigitToBools('8'));
+ new boolean[]{false, false, false, true}, Conversion.hexDigitToBoolArray('8'));
assertBoolArrayEquals(
- new boolean[]{true, false, false, true}, Conversion.hexDigitToBools('9'));
+ new boolean[]{true, false, false, true}, Conversion.hexDigitToBoolArray('9'));
assertBoolArrayEquals(
- new boolean[]{false, true, false, true}, Conversion.hexDigitToBools('A'));
+ new boolean[]{false, true, false, true}, Conversion.hexDigitToBoolArray('A'));
assertBoolArrayEquals(
- new boolean[]{false, true, false, true}, Conversion.hexDigitToBools('a'));
+ new boolean[]{false, true, false, true}, Conversion.hexDigitToBoolArray('a'));
assertBoolArrayEquals(
- new boolean[]{true, true, false, true}, Conversion.hexDigitToBools('B'));
+ new boolean[]{true, true, false, true}, Conversion.hexDigitToBoolArray('B'));
assertBoolArrayEquals(
- new boolean[]{true, true, false, true}, Conversion.hexDigitToBools('b'));
+ new boolean[]{true, true, false, true}, Conversion.hexDigitToBoolArray('b'));
assertBoolArrayEquals(
- new boolean[]{false, false, true, true}, Conversion.hexDigitToBools('C'));
+ new boolean[]{false, false, true, true}, Conversion.hexDigitToBoolArray('C'));
assertBoolArrayEquals(
- new boolean[]{false, false, true, true}, Conversion.hexDigitToBools('c'));
+ new boolean[]{false, false, true, true}, Conversion.hexDigitToBoolArray('c'));
assertBoolArrayEquals(
- new boolean[]{true, false, true, true}, Conversion.hexDigitToBools('D'));
+ new boolean[]{true, false, true, true}, Conversion.hexDigitToBoolArray('D'));
assertBoolArrayEquals(
- new boolean[]{true, false, true, true}, Conversion.hexDigitToBools('d'));
+ new boolean[]{true, false, true, true}, Conversion.hexDigitToBoolArray('d'));
assertBoolArrayEquals(
- new boolean[]{false, true, true, true}, Conversion.hexDigitToBools('E'));
+ new boolean[]{false, true, true, true}, Conversion.hexDigitToBoolArray('E'));
assertBoolArrayEquals(
- new boolean[]{false, true, true, true}, Conversion.hexDigitToBools('e'));
+ new boolean[]{false, true, true, true}, Conversion.hexDigitToBoolArray('e'));
assertBoolArrayEquals(
- new boolean[]{true, true, true, true}, Conversion.hexDigitToBools('F'));
+ new boolean[]{true, true, true, true}, Conversion.hexDigitToBoolArray('F'));
assertBoolArrayEquals(
- new boolean[]{true, true, true, true}, Conversion.hexDigitToBools('f'));
+ new boolean[]{true, true, true, true}, Conversion.hexDigitToBoolArray('f'));
try {
- Conversion.hexDigitToBools('G');
+ Conversion.hexDigitToBoolArray('G');
fail("Thrown " + IllegalArgumentException.class.getName() + " expected");
} catch (final IllegalArgumentException e) {
// OK
@@ -162,56 +162,56 @@ public class ConversionTest {
}
/**
- * Tests {@link Conversion#hexDigitM0ToBools(char)}.
+ * Tests {@link Conversion#hexDigitMsb0ToBoolArray(char)}.
*/
@Test
- public void testHexDigitM0ToBools() {
+ public void testHexDigitMsb0ToBoolArray() {
assertBoolArrayEquals(
- new boolean[]{false, false, false, false}, Conversion.hexDigitM0ToBools('0'));
+ new boolean[]{false, false, false, false}, Conversion.hexDigitMsb0ToBoolArray('0'));
assertBoolArrayEquals(
- new boolean[]{false, false, false, true}, Conversion.hexDigitM0ToBools('1'));
+ new boolean[]{false, false, false, true}, Conversion.hexDigitMsb0ToBoolArray('1'));
assertBoolArrayEquals(
- new boolean[]{false, false, true, false}, Conversion.hexDigitM0ToBools('2'));
+ new boolean[]{false, false, true, false}, Conversion.hexDigitMsb0ToBoolArray('2'));
assertBoolArrayEquals(
- new boolean[]{false, false, true, true}, Conversion.hexDigitM0ToBools('3'));
+ new boolean[]{false, false, true, true}, Conversion.hexDigitMsb0ToBoolArray('3'));
assertBoolArrayEquals(
- new boolean[]{false, true, false, false}, Conversion.hexDigitM0ToBools('4'));
+ new boolean[]{false, true, false, false}, Conversion.hexDigitMsb0ToBoolArray('4'));
assertBoolArrayEquals(
- new boolean[]{false, true, false, true}, Conversion.hexDigitM0ToBools('5'));
+ new boolean[]{false, true, false, true}, Conversion.hexDigitMsb0ToBoolArray('5'));
assertBoolArrayEquals(
- new boolean[]{false, true, true, false}, Conversion.hexDigitM0ToBools('6'));
+ new boolean[]{false, true, true, false}, Conversion.hexDigitMsb0ToBoolArray('6'));
assertBoolArrayEquals(
- new boolean[]{false, true, true, true}, Conversion.hexDigitM0ToBools('7'));
+ new boolean[]{false, true, true, true}, Conversion.hexDigitMsb0ToBoolArray('7'));
assertBoolArrayEquals(
- new boolean[]{true, false, false, false}, Conversion.hexDigitM0ToBools('8'));
+ new boolean[]{true, false, false, false}, Conversion.hexDigitMsb0ToBoolArray('8'));
assertBoolArrayEquals(
- new boolean[]{true, false, false, true}, Conversion.hexDigitM0ToBools('9'));
+ new boolean[]{true, false, false, true}, Conversion.hexDigitMsb0ToBoolArray('9'));
assertBoolArrayEquals(
- new boolean[]{true, false, true, false}, Conversion.hexDigitM0ToBools('A'));
+ new boolean[]{true, false, true, false}, Conversion.hexDigitMsb0ToBoolArray('A'));
assertBoolArrayEquals(
- new boolean[]{true, false, true, false}, Conversion.hexDigitM0ToBools('a'));
+ new boolean[]{true, false, true, false}, Conversion.hexDigitMsb0ToBoolArray('a'));
assertBoolArrayEquals(
- new boolean[]{true, false, true, true}, Conversion.hexDigitM0ToBools('B'));
+ new boolean[]{true, false, true, true}, Conversion.hexDigitMsb0ToBoolArray('B'));
assertBoolArrayEquals(
- new boolean[]{true, false, true, true}, Conversion.hexDigitM0ToBools('b'));
+ new boolean[]{true, false, true, true}, Conversion.hexDigitMsb0ToBoolArray('b'));
assertBoolArrayEquals(
- new boolean[]{true, true, false, false}, Conversion.hexDigitM0ToBools('C'));
+ new boolean[]{true, true, false, false}, Conversion.hexDigitMsb0ToBoolArray('C'));
assertBoolArrayEquals(
- new boolean[]{true, true, false, false}, Conversion.hexDigitM0ToBools('c'));
+ new boolean[]{true, true, false, false}, Conversion.hexDigitMsb0ToBoolArray('c'));
assertBoolArrayEquals(
- new boolean[]{true, true, false, true}, Conversion.hexDigitM0ToBools('D'));
+ new boolean[]{true, true, false, true}, Conversion.hexDigitMsb0ToBoolArray('D'));
assertBoolArrayEquals(
- new boolean[]{true, true, false, true}, Conversion.hexDigitM0ToBools('d'));
+ new boolean[]{true, true, false, true}, Conversion.hexDigitMsb0ToBoolArray('d'));
assertBoolArrayEquals(
- new boolean[]{true, true, true, false}, Conversion.hexDigitM0ToBools('E'));
+ new boolean[]{true, true, true, false}, Conversion.hexDigitMsb0ToBoolArray('E'));
assertBoolArrayEquals(
- new boolean[]{true, true, true, false}, Conversion.hexDigitM0ToBools('e'));
+ new boolean[]{true, true, true, false}, Conversion.hexDigitMsb0ToBoolArray('e'));
assertBoolArrayEquals(
- new boolean[]{true, true, true, true}, Conversion.hexDigitM0ToBools('F'));
+ new boolean[]{true, true, true, true}, Conversion.hexDigitMsb0ToBoolArray('F'));
assertBoolArrayEquals(
- new boolean[]{true, true, true, true}, Conversion.hexDigitM0ToBools('f'));
+ new boolean[]{true, true, true, true}, Conversion.hexDigitMsb0ToBoolArray('f'));
try {
- Conversion.hexDigitM0ToBools('G');
+ Conversion.hexDigitMsb0ToBoolArray('G');
fail("Thrown " + IllegalArgumentException.class.getName() + " expected");
} catch (final IllegalArgumentException e) {
// OK
@@ -219,31 +219,46 @@ public class ConversionTest {
}
/**
- * Tests {@link Conversion#boolsToHexDigit(boolean[])}.
+ * Tests {@link Conversion#boolArrayToHexDigit(boolean[])}.
*/
@Test
- public void testBoolsToHexDigit() {
- assertEquals('0', Conversion.boolsToHexDigit(new boolean[]{false, false, false, false}));
- assertEquals('1', Conversion.boolsToHexDigit(new boolean[]{true, false, false, false}));
- assertEquals('2', Conversion.boolsToHexDigit(new boolean[]{false, true, false, false}));
- assertEquals('3', Conversion.boolsToHexDigit(new boolean[]{true, true, false, false}));
- assertEquals('4', Conversion.boolsToHexDigit(new boolean[]{false, false, true, false}));
- assertEquals('5', Conversion.boolsToHexDigit(new boolean[]{true, false, true, false}));
- assertEquals('6', Conversion.boolsToHexDigit(new boolean[]{false, true, true, false}));
- 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('1', Conversion.boolsToHexDigit(new boolean[]{true}));
+ public void testBoolArrayToHexDigit() {
assertEquals(
- 'f', Conversion.boolsToHexDigit(new boolean[]{true, true, true, true, true}));
+ '0', Conversion.boolArrayToHexDigit(new boolean[]{false, false, false, false}));
+ assertEquals(
+ '1', Conversion.boolArrayToHexDigit(new boolean[]{true, false, false, false}));
+ assertEquals(
+ '2', Conversion.boolArrayToHexDigit(new boolean[]{false, true, false, false}));
+ assertEquals(
+ '3', Conversion.boolArrayToHexDigit(new boolean[]{true, true, false, false}));
+ assertEquals(
+ '4', Conversion.boolArrayToHexDigit(new boolean[]{false, false, true, false}));
+ assertEquals(
+ '5', Conversion.boolArrayToHexDigit(new boolean[]{true, false, true, false}));
+ assertEquals(
+ '6', Conversion.boolArrayToHexDigit(new boolean[]{false, true, true, false}));
+ assertEquals(
+ '7', Conversion.boolArrayToHexDigit(new boolean[]{true, true, true, false}));
+ assertEquals(
+ '8', Conversion.boolArrayToHexDigit(new boolean[]{false, false, false, true}));
+ assertEquals(
+ '9', Conversion.boolArrayToHexDigit(new boolean[]{true, false, false, true}));
+ assertEquals(
+ 'a', Conversion.boolArrayToHexDigit(new boolean[]{false, true, false, true}));
+ assertEquals(
+ 'b', Conversion.boolArrayToHexDigit(new boolean[]{true, true, false, true}));
+ assertEquals(
+ 'c', Conversion.boolArrayToHexDigit(new boolean[]{false, false, true, true}));
+ assertEquals(
+ 'd', Conversion.boolArrayToHexDigit(new boolean[]{true, false, true, true}));
+ assertEquals(
+ 'e', Conversion.boolArrayToHexDigit(new boolean[]{false, true, true, true}));
+ assertEquals('f', Conversion.boolArrayToHexDigit(new boolean[]{true, true, true, true}));
+ assertEquals('1', Conversion.boolArrayToHexDigit(new boolean[]{true}));
+ assertEquals(
+ 'f', Conversion.boolArrayToHexDigit(new boolean[]{true, true, true, true, true}));
try {
- Conversion.boolsToHexDigit(new boolean[]{});
+ Conversion.boolArrayToHexDigit(new boolean[]{});
fail("Thrown " + IllegalArgumentException.class.getName() + " expected");
} catch (final IllegalArgumentException e) {
// OK
@@ -251,63 +266,79 @@ public class ConversionTest {
}
/**
- * Tests {@link Conversion#boolsBeM0ToHexDigit(boolean[], int)}.
+ * Tests {@link Conversion#boolArrayBeMsb0ToHexDigit(boolean[], int)}.
*/
@Test
- public void testBoolsToHexDigit_2args() {
+ public void testBoolArrayToHexDigit_2args() {
boolean[] shortArray = new boolean[]{false, true, true};
- assertEquals('6', Conversion.boolsToHexDigit(shortArray, 0));
- assertEquals('3', Conversion.boolsToHexDigit(shortArray, 1));
- assertEquals('1', Conversion.boolsToHexDigit(shortArray, 2));
+ assertEquals('6', Conversion.boolArrayToHexDigit(shortArray, 0));
+ assertEquals('3', Conversion.boolArrayToHexDigit(shortArray, 1));
+ assertEquals('1', Conversion.boolArrayToHexDigit(shortArray, 2));
boolean[] longArray = new boolean[]{true, false, true, false, false, true, true};
- 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('6', Conversion.boolsToHexDigit(longArray, 4));
- assertEquals('3', Conversion.boolsToHexDigit(longArray, 5));
- assertEquals('1', Conversion.boolsToHexDigit(longArray, 6));
+ assertEquals('5', Conversion.boolArrayToHexDigit(longArray, 0));
+ assertEquals('2', Conversion.boolArrayToHexDigit(longArray, 1));
+ assertEquals('9', Conversion.boolArrayToHexDigit(longArray, 2));
+ assertEquals('c', Conversion.boolArrayToHexDigit(longArray, 3));
+ assertEquals('6', Conversion.boolArrayToHexDigit(longArray, 4));
+ assertEquals('3', Conversion.boolArrayToHexDigit(longArray, 5));
+ assertEquals('1', Conversion.boolArrayToHexDigit(longArray, 6));
}
/**
- * Tests {@link Conversion#boolsToHexDigitM0_4bits(boolean[])}.
+ * Tests {@link Conversion#boolArrayToHexDigitMsb0_4bits(boolean[])}.
*/
@Test
- public void testBoolsToHexDigitM0_bits() {
+ public void testBoolArrayToHexDigitMsb0_bits() {
assertEquals(
- '0', Conversion.boolsToHexDigitM0_4bits(new boolean[]{false, false, false, false}));
+ '0',
+ Conversion.boolArrayToHexDigitMsb0_4bits(new boolean[]{false, false, false, false}));
assertEquals(
- '1', Conversion.boolsToHexDigitM0_4bits(new boolean[]{false, false, false, true}));
+ '1',
+ Conversion.boolArrayToHexDigitMsb0_4bits(new boolean[]{false, false, false, true}));
assertEquals(
- '2', Conversion.boolsToHexDigitM0_4bits(new boolean[]{false, false, true, false}));
+ '2',
+ Conversion.boolArrayToHexDigitMsb0_4bits(new boolean[]{false, false, true, false}));
assertEquals(
- '3', Conversion.boolsToHexDigitM0_4bits(new boolean[]{false, false, true, true}));
+ '3',
+ Conversion.boolArrayToHexDigitMsb0_4bits(new boolean[]{false, false, true, true}));
assertEquals(
- '4', Conversion.boolsToHexDigitM0_4bits(new boolean[]{false, true, false, false}));
+ '4',
+ Conversion.boolArrayToHexDigitMsb0_4bits(new boolean[]{false, true, false, false}));
assertEquals(
- '5', Conversion.boolsToHexDigitM0_4bits(new boolean[]{false, true, false, true}));
+ '5',
+ Conversion.boolArrayToHexDigitMsb0_4bits(new boolean[]{false, true, false, true}));
assertEquals(
- '6', Conversion.boolsToHexDigitM0_4bits(new boolean[]{false, true, true, false}));
+ '6',
+ Conversion.boolArrayToHexDigitMsb0_4bits(new boolean[]{false, true, true, false}));
assertEquals(
- '7', Conversion.boolsToHexDigitM0_4bits(new boolean[]{false, true, true, true}));
+ '7',
+ Conversion.boolArrayToHexDigitMsb0_4bits(new boolean[]{false, true, true, true}));
assertEquals(
- '8', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, false, false, false}));
+ '8',
+ Conversion.boolArrayToHexDigitMsb0_4bits(new boolean[]{true, false, false, false}));
assertEquals(
- '9', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, false, false, true}));
+ '9',
+ Conversion.boolArrayToHexDigitMsb0_4bits(new boolean[]{true, false, false, true}));
assertEquals(
- 'a', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, false, true, false}));
+ 'a',
+ Conversion.boolArrayToHexDigitMsb0_4bits(new boolean[]{true, false, true, false}));
assertEquals(
- 'b', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, false, true, true}));
+ 'b',
+ Conversion.boolArrayToHexDigitMsb0_4bits(new boolean[]{true, false, true, true}));
assertEquals(
- 'c', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, true, false, false}));
+ 'c',
+ Conversion.boolArrayToHexDigitMsb0_4bits(new boolean[]{true, true, false, false}));
assertEquals(
- 'd', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, true, false, true}));
+ 'd',
+ Conversion.boolArrayToHexDigitMsb0_4bits(new boolean[]{true, true, false, true}));
assertEquals(
- 'e', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, true, true, false}));
+ 'e',
+ Conversion.boolArrayToHexDigitMsb0_4bits(new boolean[]{true, true, true, false}));
assertEquals(
- 'f', Conversion.boolsToHexDigitM0_4bits(new boolean[]{true, true, true, true}));
+ 'f',
+ Conversion.boolArrayToHexDigitMsb0_4bits(new boolean[]{true, true, true, true}));
try {
- Conversion.boolsToHexDigitM0_4bits(new boolean[]{});
+ Conversion.boolArrayToHexDigitMsb0_4bits(new boolean[]{});
fail("Thrown " + IllegalArgumentException.class.getName() + " expected");
} catch (final IllegalArgumentException e) {
// OK
@@ -315,83 +346,85 @@ public class ConversionTest {
}
/**
- * Tests {@link Conversion#boolsToHexDigitM0_4bits(boolean[], int)}.
+ * Tests {@link Conversion#boolArrayToHexDigitMsb0_4bits(boolean[], int)}.
*/
@Test
- public void testBoolsToHexDigitM0_4bits_2args() {
+ public void testBoolArrayToHexDigitMsb0_4bits_2args() {
// boolean[] shortArray = new boolean[]{true,true,false};
- // assertEquals('6', Conversion.boolsToHexDigitM0(shortArray,0));
- // assertEquals('3', Conversion.boolsToHexDigitM0(shortArray,1));
- // assertEquals('1', Conversion.boolsToHexDigitM0(shortArray,2));
+ // assertEquals('6', Conversion.BoolArrayToHexDigitMsb0(shortArray,0));
+ // assertEquals('3', Conversion.BoolArrayToHexDigitMsb0(shortArray,1));
+ // assertEquals('1', Conversion.BoolArrayToHexDigitMsb0(shortArray,2));
boolean[] shortArray = new boolean[]{true, true, false, true};
- assertEquals('d', Conversion.boolsToHexDigitM0_4bits(shortArray, 0));
+ assertEquals('d', Conversion.boolArrayToHexDigitMsb0_4bits(shortArray, 0));
boolean[] longArray = new boolean[]{true, false, true, false, false, true, true};
- 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));
- // assertEquals('6', Conversion.boolsToHexDigitM0(longArray,4));
- // assertEquals('3', Conversion.boolsToHexDigitM0(longArray,5));
- // assertEquals('1', Conversion.boolsToHexDigitM0(longArray,6));
+ assertEquals('a', Conversion.boolArrayToHexDigitMsb0_4bits(longArray, 0));
+ assertEquals('4', Conversion.boolArrayToHexDigitMsb0_4bits(longArray, 1));
+ assertEquals('9', Conversion.boolArrayToHexDigitMsb0_4bits(longArray, 2));
+ assertEquals('3', Conversion.boolArrayToHexDigitMsb0_4bits(longArray, 3));
+ // assertEquals('6', Conversion.BoolArrayToHexDigitMsb0(longArray,4));
+ // assertEquals('3', Conversion.BoolArrayToHexDigitMsb0(longArray,5));
+ // assertEquals('1', Conversion.BoolArrayToHexDigitMsb0(longArray,6));
boolean[] maxLengthArray = new boolean[]{
true, false, true, false, false, true, true, true};
- 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));
- assertEquals('7', Conversion.boolsToHexDigitM0_4bits(maxLengthArray, 4));
- // assertEquals('7', Conversion.boolsToHexDigitM0(longArray,5));
- // assertEquals('3', Conversion.boolsToHexDigitM0(longArray,6));
- // assertEquals('1', Conversion.boolsToHexDigitM0(longArray,7));
+ assertEquals('a', Conversion.boolArrayToHexDigitMsb0_4bits(maxLengthArray, 0));
+ assertEquals('4', Conversion.boolArrayToHexDigitMsb0_4bits(maxLengthArray, 1));
+ assertEquals('9', Conversion.boolArrayToHexDigitMsb0_4bits(maxLengthArray, 2));
+ assertEquals('3', Conversion.boolArrayToHexDigitMsb0_4bits(maxLengthArray, 3));
+ assertEquals('7', Conversion.boolArrayToHexDigitMsb0_4bits(maxLengthArray, 4));
+ // assertEquals('7', Conversion.BoolArrayToHexDigitMsb0(longArray,5));
+ // assertEquals('3', Conversion.BoolArrayToHexDigitMsb0(longArray,6));
+ // assertEquals('1', Conversion.BoolArrayToHexDigitMsb0(longArray,7));
boolean[] javaDocCheck = new boolean[]{
true, false, false, true, true, false, true, false};
- assertEquals('d', Conversion.boolsToHexDigitM0_4bits(javaDocCheck, 3));
+ assertEquals('d', Conversion.boolArrayToHexDigitMsb0_4bits(javaDocCheck, 3));
}
/**
- * Tests {@link Conversion#boolsToHexDigit(boolean[])}.
+ * Tests {@link Conversion#boolArrayToHexDigit(boolean[])}.
*/
@Test
- public void testBoolsBeM0ToHexDigit() {
+ public void testBoolArrayBeMsb0ToHexDigit() {
assertEquals(
- '0', Conversion.boolsBeM0ToHexDigit(new boolean[]{false, false, false, false}));
+ '0',
+ Conversion.boolArrayBeMsb0ToHexDigit(new boolean[]{false, false, false, false}));
assertEquals(
- '1', Conversion.boolsBeM0ToHexDigit(new boolean[]{false, false, false, true}));
+ '1', Conversion.boolArrayBeMsb0ToHexDigit(new boolean[]{false, false, false, true}));
assertEquals(
- '2', Conversion.boolsBeM0ToHexDigit(new boolean[]{false, false, true, false}));
+ '2', Conversion.boolArrayBeMsb0ToHexDigit(new boolean[]{false, false, true, false}));
assertEquals(
- '3', Conversion.boolsBeM0ToHexDigit(new boolean[]{false, false, true, true}));
+ '3', Conversion.boolArrayBeMsb0ToHexDigit(new boolean[]{false, false, true, true}));
assertEquals(
- '4', Conversion.boolsBeM0ToHexDigit(new boolean[]{false, true, false, false}));
+ '4', Conversion.boolArrayBeMsb0ToHexDigit(new boolean[]{false, true, false, false}));
assertEquals(
- '5', Conversion.boolsBeM0ToHexDigit(new boolean[]{false, true, false, true}));
+ '5', Conversion.boolArrayBeMsb0ToHexDigit(new boolean[]{false, true, false, true}));
assertEquals(
- '6', Conversion.boolsBeM0ToHexDigit(new boolean[]{false, true, true, false}));
+ '6', Conversion.boolArrayBeMsb0ToHexDigit(new boolean[]{false, true, true, false}));
assertEquals(
- '7', Conversion.boolsBeM0ToHexDigit(new boolean[]{false, true, true, true}));
+ '7', Conversion.boolArrayBeMsb0ToHexDigit(new boolean[]{false, true, true, true}));
assertEquals(
- '8', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, false, false, false}));
+ '8', Conversion.boolArrayBeMsb0ToHexDigit(new boolean[]{true, false, false, false}));
assertEquals(
- '9', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, false, false, true}));
+ '9', Conversion.boolArrayBeMsb0ToHexDigit(new boolean[]{true, false, false, true}));
assertEquals(
- 'a', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, false, true, false}));
+ 'a', Conversion.boolArrayBeMsb0ToHexDigit(new boolean[]{true, false, true, false}));
assertEquals(
- 'b', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, false, true, true}));
+ 'b', Conversion.boolArrayBeMsb0ToHexDigit(new boolean[]{true, false, true, true}));
assertEquals(
- 'c', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, true, false, false}));
+ 'c', Conversion.boolArrayBeMsb0ToHexDigit(new boolean[]{true, true, false, false}));
assertEquals(
- 'd', Conversion.boolsBeM0ToHexDigit(new boolean[]{true, true, false, true}));
+ 'd', Conversion.boolArrayBeMsb0ToHexDigit(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.boolArrayBeMsb0ToHexDigit(new boolean[]{true, true, true, false}));
+ assertEquals(
+ 'f', Conversion.boolArrayBeMsb0ToHexDigit(new boolean[]{true, true, true, true}));
assertEquals(
'4',
- Conversion.boolsBeM0ToHexDigit(new boolean[]{
+ Conversion.boolArrayBeMsb0ToHexDigit(new boolean[]{
true, false, false, false, false, false, false, false, false, false, false,
false, false, true, false, false}));
try {
- Conversion.boolsBeM0ToHexDigit(new boolean[]{});
+ Conversion.boolArrayBeMsb0ToHexDigit(new boolean[]{});
fail("Thrown " + IllegalArgumentException.class.getName() + " expected");
} catch (final IllegalArgumentException e) {
// OK
@@ -399,49 +432,49 @@ public class ConversionTest {
}
/**
- * Tests {@link Conversion#boolsToHexDigit(boolean[], int)}.
+ * Tests {@link Conversion#boolArrayToHexDigit(boolean[], int)}.
*/
@Test
- public void testBoolsBeM0ToHexDigit_2args() {
+ public void testBoolArrayBeMsb0ToHexDigit_2args() {
assertEquals(
'5',
- Conversion.boolsBeM0ToHexDigit(new boolean[]{
+ Conversion.boolArrayBeMsb0ToHexDigit(new boolean[]{
true, false, false, false, false, false, false, false, false, false, false,
true, false, true, false, false}, 2));
boolean[] shortArray = new boolean[]{true, true, false};
- assertEquals('6', Conversion.boolsBeM0ToHexDigit(shortArray, 0));
- assertEquals('3', Conversion.boolsBeM0ToHexDigit(shortArray, 1));
- assertEquals('1', Conversion.boolsBeM0ToHexDigit(shortArray, 2));
+ assertEquals('6', Conversion.boolArrayBeMsb0ToHexDigit(shortArray, 0));
+ assertEquals('3', Conversion.boolArrayBeMsb0ToHexDigit(shortArray, 1));
+ assertEquals('1', Conversion.boolArrayBeMsb0ToHexDigit(shortArray, 2));
boolean[] shortArray2 = new boolean[]{true, true, true, false, false, true, false, true};
- 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('7', Conversion.boolsBeM0ToHexDigit(shortArray2, 5));
- assertEquals('3', Conversion.boolsBeM0ToHexDigit(shortArray2, 6));
- assertEquals('1', Conversion.boolsBeM0ToHexDigit(shortArray2, 7));
+ assertEquals('5', Conversion.boolArrayBeMsb0ToHexDigit(shortArray2, 0));
+ assertEquals('2', Conversion.boolArrayBeMsb0ToHexDigit(shortArray2, 1));
+ assertEquals('9', Conversion.boolArrayBeMsb0ToHexDigit(shortArray2, 2));
+ assertEquals('c', Conversion.boolArrayBeMsb0ToHexDigit(shortArray2, 3));
+ assertEquals('e', Conversion.boolArrayBeMsb0ToHexDigit(shortArray2, 4));
+ assertEquals('7', Conversion.boolArrayBeMsb0ToHexDigit(shortArray2, 5));
+ assertEquals('3', Conversion.boolArrayBeMsb0ToHexDigit(shortArray2, 6));
+ assertEquals('1', Conversion.boolArrayBeMsb0ToHexDigit(shortArray2, 7));
boolean[] multiBytesArray = new boolean[]{
true, true, false, false, true, false, true, false, true, true, true, false, false,
true, false, true};
- 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('7', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 5));
- assertEquals('b', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 6));
- assertEquals('5', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 7));
-
- 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('6', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 13));
- assertEquals('3', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 14));
- assertEquals('1', Conversion.boolsBeM0ToHexDigit(multiBytesArray, 15));
+ assertEquals('5', Conversion.boolArrayBeMsb0ToHexDigit(multiBytesArray, 0));
+ assertEquals('2', Conversion.boolArrayBeMsb0ToHexDigit(multiBytesArray, 1));
+ assertEquals('9', Conversion.boolArrayBeMsb0ToHexDigit(multiBytesArray, 2));
+ assertEquals('c', Conversion.boolArrayBeMsb0ToHexDigit(multiBytesArray, 3));
+ assertEquals('e', Conversion.boolArrayBeMsb0ToHexDigit(multiBytesArray, 4));
+ assertEquals('7', Conversion.boolArrayBeMsb0ToHexDigit(multiBytesArray, 5));
+ assertEquals('b', Conversion.boolArrayBeMsb0ToHexDigit(multiBytesArray, 6));
+ assertEquals('5', Conversion.boolArrayBeMsb0ToHexDigit(multiBytesArray, 7));
+
+ assertEquals('a', Conversion.boolArrayBeMsb0ToHexDigit(multiBytesArray, 8));
+ assertEquals('5', Conversion.boolArrayBeMsb0ToHexDigit(multiBytesArray, 9));
+ assertEquals('2', Conversion.boolArrayBeMsb0ToHexDigit(multiBytesArray, 10));
+ assertEquals('9', Conversion.boolArrayBeMsb0ToHexDigit(multiBytesArray, 11));
+ assertEquals('c', Conversion.boolArrayBeMsb0ToHexDigit(multiBytesArray, 12));
+ assertEquals('6', Conversion.boolArrayBeMsb0ToHexDigit(multiBytesArray, 13));
+ assertEquals('3', Conversion.boolArrayBeMsb0ToHexDigit(multiBytesArray, 14));
+ assertEquals('1', Conversion.boolArrayBeMsb0ToHexDigit(multiBytesArray, 15));
}
@@ -475,28 +508,28 @@ public class ConversionTest {
}
/**
- * Tests {@link Conversion#intToHexDigitM0(int)}.
+ * Tests {@link Conversion#intToHexDigitMsb0(int)}.
*/
@Test
- public void testIntToHexDigitM0() {
- assertEquals('0', Conversion.intToHexDigitM0(0));
- assertEquals('8', Conversion.intToHexDigitM0(1));
- assertEquals('4', Conversion.intToHexDigitM0(2));
- assertEquals('c', Conversion.intToHexDigitM0(3));
- assertEquals('2', Conversion.intToHexDigitM0(4));
- assertEquals('a', Conversion.intToHexDigitM0(5));
- assertEquals('6', Conversion.intToHexDigitM0(6));
- 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('3', Conversion.intToHexDigitM0(12));
- assertEquals('b', Conversion.intToHexDigitM0(13));
- assertEquals('7', Conversion.intToHexDigitM0(14));
- assertEquals('f', Conversion.intToHexDigitM0(15));
+ public void testIntToHexDigitMsb0() {
+ assertEquals('0', Conversion.intToHexDigitMsb0(0));
+ assertEquals('8', Conversion.intToHexDigitMsb0(1));
+ assertEquals('4', Conversion.intToHexDigitMsb0(2));
+ assertEquals('c', Conversion.intToHexDigitMsb0(3));
+ assertEquals('2', Conversion.intToHexDigitMsb0(4));
+ assertEquals('a', Conversion.intToHexDigitMsb0(5));
+ assertEquals('6', Conversion.intToHexDigitMsb0(6));
+ assertEquals('e', Conversion.intToHexDigitMsb0(7));
+ assertEquals('1', Conversion.intToHexDigitMsb0(8));
+ assertEquals('9', Conversion.intToHexDigitMsb0(9));
+ assertEquals('5', Conversion.intToHexDigitMsb0(10));
+ assertEquals('d', Conversion.intToHexDigitMsb0(11));
+ assertEquals('3', Conversion.intToHexDigitMsb0(12));
+ assertEquals('b', Conversion.intToHexDigitMsb0(13));
+ assertEquals('7', Conversion.intToHexDigitMsb0(14));
+ assertEquals('f', Conversion.intToHexDigitMsb0(15));
try {
- Conversion.intToHexDigitM0(16);
+ Conversion.intToHexDigitMsb0(16);
fail("Thrown " + IllegalArgumentException.class.getName() + " expected");
} catch (final IllegalArgumentException e) {
// OK
@@ -535,175 +568,178 @@ public class ConversionTest {
}
/**
- * Tests {@link Conversion#intsToLong(int[], int, long, int, int)}.
+ * Tests {@link Conversion#intArrayToLong(int[], int, long, int, int)}.
*/
@Test
- public void testIntsToLong() {
+ public void testIntArrayToLong() {
int[] src = new int[]{0xCDF1F0C1, 0x0F123456, 0x78000000};
- assertEquals(0x0000000000000000L, Conversion.intsToLong(src, 0, 0L, 0, 0));
- assertEquals(0x0000000000000000L, Conversion.intsToLong(src, 1, 0L, 0, 0));
- assertEquals(0x00000000CDF1F0C1L, Conversion.intsToLong(src, 0, 0L, 0, 1));
- assertEquals(0x0F123456CDF1F0C1L, Conversion.intsToLong(src, 0, 0L, 0, 2));
- assertEquals(0x000000000F123456L, Conversion.intsToLong(src, 1, 0L, 0, 1));
+ assertEquals(0x0000000000000000L, Conversion.intArrayToLong(src, 0, 0L, 0, 0));
+ assertEquals(0x0000000000000000L, Conversion.intArrayToLong(src, 1, 0L, 0, 0));
+ assertEquals(0x00000000CDF1F0C1L, Conversion.intArrayToLong(src, 0, 0L, 0, 1));
+ assertEquals(0x0F123456CDF1F0C1L, Conversion.intArrayToLong(src, 0, 0L, 0, 2));
+ assertEquals(0x000000000F123456L, Conversion.intArrayToLong(src, 1, 0L, 0, 1));
assertEquals(
- 0x123456789ABCDEF0L, Conversion.intsToLong(src, 0, 0x123456789ABCDEF0L, 0, 0));
+ 0x123456789ABCDEF0L, Conversion.intArrayToLong(src, 0, 0x123456789ABCDEF0L, 0, 0));
assertEquals(
- 0x1234567878000000L, Conversion.intsToLong(src, 2, 0x123456789ABCDEF0L, 0, 1));
+ 0x1234567878000000L, Conversion.intArrayToLong(src, 2, 0x123456789ABCDEF0L, 0, 1));
// assertEquals(0x0F12345678000000L,Conversion.intsToLong(src,1,0x123456789ABCDEF0L,32,2));
}
/**
- * Tests {@link Conversion#shortsToLong(short[], int, long, int, int)}.
+ * Tests {@link Conversion#shortArrayToLong(short[], int, long, int, int)}.
*/
@Test
- public void testShortsToLong() {
+ public void testShortArrayToLong() {
short[] src = new short[]{
(short)0xCDF1, (short)0xF0C1, (short)0x0F12, (short)0x3456, (short)0x7800};
- assertEquals(0x0000000000000000L, Conversion.shortsToLong(src, 0, 0L, 0, 0));
- assertEquals(0x000000000000CDF1L, Conversion.shortsToLong(src, 0, 0L, 0, 1));
- assertEquals(0x00000000F0C1CDF1L, Conversion.shortsToLong(src, 0, 0L, 0, 2));
- assertEquals(0x780034560F12F0C1L, Conversion.shortsToLong(src, 1, 0L, 0, 4));
+ assertEquals(0x0000000000000000L, Conversion.shortArrayToLong(src, 0, 0L, 0, 0));
+ assertEquals(0x000000000000CDF1L, Conversion.shortArrayToLong(src, 0, 0L, 0, 1));
+ assertEquals(0x00000000F0C1CDF1L, Conversion.shortArrayToLong(src, 0, 0L, 0, 2));
+ assertEquals(0x780034560F12F0C1L, Conversion.shortArrayToLong(src, 1, 0L, 0, 4));
assertEquals(
- 0x123456789ABCDEF0L, Conversion.shortsToLong(src, 0, 0x123456789ABCDEF0L, 0, 0));
+ 0x123456789ABCDEF0L, Conversion.shortArrayToLong(src, 0, 0x123456789ABCDEF0L, 0, 0));
assertEquals(
- 0x123456CDF1BCDEF0L, Conversion.shortsToLong(src, 0, 0x123456789ABCDEF0L, 24, 1));
+ 0x123456CDF1BCDEF0L,
+ Conversion.shortArrayToLong(src, 0, 0x123456789ABCDEF0L, 24, 1));
assertEquals(
- 0x123478003456DEF0L, Conversion.shortsToLong(src, 3, 0x123456789ABCDEF0L, 16, 2));
+ 0x123478003456DEF0L,
+ Conversion.shortArrayToLong(src, 3, 0x123456789ABCDEF0L, 16, 2));
}
/**
- * Tests {@link Conversion#bytesToLong(byte[], int, long, int, int)}.
+ * Tests {@link Conversion#byteArrayToLong(byte[], int, long, int, int)}.
*/
@Test
- public void testBytesToLong() {
+ public void testByteArrayToLong() {
byte[] src = new byte[]{
(byte)0xCD, (byte)0xF1, (byte)0xF0, (byte)0xC1, (byte)0x0F, (byte)0x12, (byte)0x34,
(byte)0x56, (byte)0x78};
- assertEquals(0x0000000000000000L, Conversion.bytesToLong(src, 0, 0L, 0, 0));
- assertEquals(0x00000000000000CDL, Conversion.bytesToLong(src, 0, 0L, 0, 1));
- assertEquals(0x00000000C1F0F1CDL, Conversion.bytesToLong(src, 0, 0L, 0, 4));
- assertEquals(0x000000000FC1F0F1L, Conversion.bytesToLong(src, 1, 0L, 0, 4));
+ assertEquals(0x0000000000000000L, Conversion.byteArrayToLong(src, 0, 0L, 0, 0));
+ assertEquals(0x00000000000000CDL, Conversion.byteArrayToLong(src, 0, 0L, 0, 1));
+ assertEquals(0x00000000C1F0F1CDL, Conversion.byteArrayToLong(src, 0, 0L, 0, 4));
+ assertEquals(0x000000000FC1F0F1L, Conversion.byteArrayToLong(src, 1, 0L, 0, 4));
assertEquals(
- 0x123456789ABCDEF0L, Conversion.bytesToLong(src, 0, 0x123456789ABCDEF0L, 0, 0));
+ 0x123456789ABCDEF0L, Conversion.byteArrayToLong(src, 0, 0x123456789ABCDEF0L, 0, 0));
assertEquals(
- 0x12345678CDBCDEF0L, Conversion.bytesToLong(src, 0, 0x123456789ABCDEF0L, 24, 1));
+ 0x12345678CDBCDEF0L, Conversion.byteArrayToLong(src, 0, 0x123456789ABCDEF0L, 24, 1));
assertEquals(
- 0x123456789A7856F0L, Conversion.bytesToLong(src, 7, 0x123456789ABCDEF0L, 8, 2));
+ 0x123456789A7856F0L, Conversion.byteArrayToLong(src, 7, 0x123456789ABCDEF0L, 8, 2));
}
/**
- * Tests {@link Conversion#shortsToInt(short[], int, int, int, int)}.
+ * Tests {@link Conversion#shortArrayToInt(short[], int, int, int, int)}.
*/
@Test
- public void testShortsToInt() {
+ public void testShortArrayToInt() {
short[] src = new short[]{
(short)0xCDF1, (short)0xF0C1, (short)0x0F12, (short)0x3456, (short)0x7800};
- assertEquals(0x00000000, Conversion.shortsToInt(src, 0, 0, 0, 0));
- assertEquals(0x0000CDF1, Conversion.shortsToInt(src, 0, 0, 0, 1));
- assertEquals(0xF0C1CDF1, Conversion.shortsToInt(src, 0, 0, 0, 2));
- assertEquals(0x0F12F0C1, Conversion.shortsToInt(src, 1, 0, 0, 2));
- assertEquals(0x12345678, Conversion.shortsToInt(src, 0, 0x12345678, 0, 0));
- assertEquals(0xCDF15678, Conversion.shortsToInt(src, 0, 0x12345678, 16, 1));
- // assertEquals(0x34567800,Conversion.shortsToInt(src, 3, 0x12345678, 16, 2));
+ assertEquals(0x00000000, Conversion.shortArrayToInt(src, 0, 0, 0, 0));
+ assertEquals(0x0000CDF1, Conversion.shortArrayToInt(src, 0, 0, 0, 1));
+ assertEquals(0xF0C1CDF1, Conversion.shortArrayToInt(src, 0, 0, 0, 2));
+ assertEquals(0x0F12F0C1, Conversion.shortArrayToInt(src, 1, 0, 0, 2));
+ assertEquals(0x12345678, Conversion.shortArrayToInt(src, 0, 0x12345678, 0, 0));
+ assertEquals(0xCDF15678, Conversion.shortArrayToInt(src, 0, 0x12345678, 16, 1));
+ // assertEquals(0x34567800,Conversion.ShortArrayToInt(src, 3, 0x12345678, 16, 2));
}
/**
- * Tests {@link Conversion#bytesToInt(byte[], int, int, int, int)}.
+ * Tests {@link Conversion#byteArrayToInt(byte[], int, int, int, int)}.
*/
@Test
- public void testBytesToInt() {
+ public void testByteArrayToInt() {
byte[] src = new byte[]{
(byte)0xCD, (byte)0xF1, (byte)0xF0, (byte)0xC1, (byte)0x0F, (byte)0x12, (byte)0x34,
(byte)0x56, (byte)0x78};
- assertEquals(0x00000000, Conversion.bytesToInt(src, 0, 0, 0, 0));
- assertEquals(0x000000CD, Conversion.bytesToInt(src, 0, 0, 0, 1));
- assertEquals(0xC1F0F1CD, Conversion.bytesToInt(src, 0, 0, 0, 4));
- assertEquals(0x0FC1F0F1, Conversion.bytesToInt(src, 1, 0, 0, 4));
- assertEquals(0x12345678, Conversion.bytesToInt(src, 0, 0x12345678, 0, 0));
- assertEquals(0xCD345678, Conversion.bytesToInt(src, 0, 0x12345678, 24, 1));
- // assertEquals(0x56341278,Conversion.bytesToInt(src, 5, 0x01234567, 8, 4));
+ assertEquals(0x00000000, Conversion.byteArrayToInt(src, 0, 0, 0, 0));
+ assertEquals(0x000000CD, Conversion.byteArrayToInt(src, 0, 0, 0, 1));
+ assertEquals(0xC1F0F1CD, Conversion.byteArrayToInt(src, 0, 0, 0, 4));
+ assertEquals(0x0FC1F0F1, Conversion.byteArrayToInt(src, 1, 0, 0, 4));
+ assertEquals(0x12345678, Conversion.byteArrayToInt(src, 0, 0x12345678, 0, 0));
+ assertEquals(0xCD345678, Conversion.byteArrayToInt(src, 0, 0x12345678, 24, 1));
+ // assertEquals(0x56341278,Conversion.ByteArrayToInt(src, 5, 0x01234567, 8, 4));
}
/**
- * Tests {@link Conversion#bytesToShort(byte[], int, short, int, int)}.
+ * Tests {@link Conversion#byteArrayToShort(byte[], int, short, int, int)}.
*/
@Test
- public void testBytesToShort() {
+ public void testByteArrayToShort() {
byte[] src = new byte[]{
(byte)0xCD, (byte)0xF1, (byte)0xF0, (byte)0xC1, (byte)0x0F, (byte)0x12, (byte)0x34,
(byte)0x56, (byte)0x78};
- assertEquals((short)0x0000, Conversion.bytesToShort(src, 0, (short)0, 0, 0));
- assertEquals((short)0x00CD, Conversion.bytesToShort(src, 0, (short)0, 0, 1));
- assertEquals((short)0xF1CD, Conversion.bytesToShort(src, 0, (short)0, 0, 2));
- assertEquals((short)0xF0F1, Conversion.bytesToShort(src, 1, (short)0, 0, 2));
- assertEquals((short)0x1234, Conversion.bytesToShort(src, 0, (short)0x1234, 0, 0));
- assertEquals((short)0xCD34, Conversion.bytesToShort(src, 0, (short)0x1234, 8, 1));
- // assertEquals((short)0x5678,Conversion.bytesToShort(src, 7, (short) 0x0123, 8, 2));
+ assertEquals((short)0x0000, Conversion.byteArrayToShort(src, 0, (short)0, 0, 0));
+ assertEquals((short)0x00CD, Conversion.byteArrayToShort(src, 0, (short)0, 0, 1));
+ assertEquals((short)0xF1CD, Conversion.byteArrayToShort(src, 0, (short)0, 0, 2));
+ assertEquals((short)0xF0F1, Conversion.byteArrayToShort(src, 1, (short)0, 0, 2));
+ assertEquals((short)0x1234, Conversion.byteArrayToShort(src, 0, (short)0x1234, 0, 0));
+ assertEquals((short)0xCD34, Conversion.byteArrayToShort(src, 0, (short)0x1234, 8, 1));
+ // assertEquals((short)0x5678,Conversion.ByteArrayToShort(src, 7, (short) 0x0123, 8,
+ // 2));
}
/**
- * Tests {@link Conversion#hexsToLong(String, int, long, int, int)}.
+ * Tests {@link Conversion#hexToLong(String, int, long, int, int)}.
*/
@Test
- public void testHexsToLong() {
+ public void testHexToLong() {
String src = "CDF1F0C10F12345678";
- assertEquals(0x0000000000000000L, Conversion.hexsToLong(src, 0, 0L, 0, 0));
- assertEquals(0x000000000000000CL, Conversion.hexsToLong(src, 0, 0L, 0, 1));
- assertEquals(0x000000001C0F1FDCL, Conversion.hexsToLong(src, 0, 0L, 0, 8));
- assertEquals(0x0000000001C0F1FDL, Conversion.hexsToLong(src, 1, 0L, 0, 8));
+ assertEquals(0x0000000000000000L, Conversion.hexToLong(src, 0, 0L, 0, 0));
+ assertEquals(0x000000000000000CL, Conversion.hexToLong(src, 0, 0L, 0, 1));
+ assertEquals(0x000000001C0F1FDCL, Conversion.hexToLong(src, 0, 0L, 0, 8));
+ assertEquals(0x0000000001C0F1FDL, Conversion.hexToLong(src, 1, 0L, 0, 8));
assertEquals(
- 0x123456798ABCDEF0L, Conversion.hexsToLong(src, 0, 0x123456798ABCDEF0L, 0, 0));
+ 0x123456798ABCDEF0L, Conversion.hexToLong(src, 0, 0x123456798ABCDEF0L, 0, 0));
assertEquals(
- 0x1234567876BCDEF0L, Conversion.hexsToLong(src, 15, 0x123456798ABCDEF0L, 24, 3));
+ 0x1234567876BCDEF0L, Conversion.hexToLong(src, 15, 0x123456798ABCDEF0L, 24, 3));
}
/**
- * Tests {@link Conversion#hexsToInt(String, int, int, int, int)}.
+ * Tests {@link Conversion#hexToInt(String, int, int, int, int)}.
*/
@Test
- public void testHexsToInt() {
+ public void testHexToInt() {
String src = "CDF1F0C10F12345678";
- assertEquals(0x00000000, Conversion.hexsToInt(src, 0, 0, 0, 0));
- assertEquals(0x0000000C, Conversion.hexsToInt(src, 0, 0, 0, 1));
- assertEquals(0x1C0F1FDC, Conversion.hexsToInt(src, 0, 0, 0, 8));
- assertEquals(0x01C0F1FD, Conversion.hexsToInt(src, 1, 0, 0, 8));
- assertEquals(0x12345679, Conversion.hexsToInt(src, 0, 0x12345679, 0, 0));
- assertEquals(0x87645679, Conversion.hexsToInt(src, 15, 0x12345679, 20, 3));
+ assertEquals(0x00000000, Conversion.hexToInt(src, 0, 0, 0, 0));
+ assertEquals(0x0000000C, Conversion.hexToInt(src, 0, 0, 0, 1));
+ assertEquals(0x1C0F1FDC, Conversion.hexToInt(src, 0, 0, 0, 8));
+ assertEquals(0x01C0F1FD, Conversion.hexToInt(src, 1, 0, 0, 8));
+ assertEquals(0x12345679, Conversion.hexToInt(src, 0, 0x12345679, 0, 0));
+ assertEquals(0x87645679, Conversion.hexToInt(src, 15, 0x12345679, 20, 3));
}
/**
- * Tests {@link Conversion#hexsToShort(String, int, short, int, int)}.
+ * Tests {@link Conversion#hexToShort(String, int, short, int, int)}.
*/
@Test
- public void testHexsToShort() {
+ public void testHexToShort() {
String src = "CDF1F0C10F12345678";
- assertEquals((short)0x0000, Conversion.hexsToShort(src, 0, (short)0, 0, 0));
- assertEquals((short)0x000C, Conversion.hexsToShort(src, 0, (short)0, 0, 1));
- assertEquals((short)0x1FDC, Conversion.hexsToShort(src, 0, (short)0, 0, 4));
- assertEquals((short)0xF1FD, Conversion.hexsToShort(src, 1, (short)0, 0, 4));
- assertEquals((short)0x1234, Conversion.hexsToShort(src, 0, (short)0x1234, 0, 0));
- assertEquals((short)0x8764, Conversion.hexsToShort(src, 15, (short)0x1234, 4, 3));
+ assertEquals((short)0x0000, Conversion.hexToShort(src, 0, (short)0, 0, 0));
+ assertEquals((short)0x000C, Conversion.hexToShort(src, 0, (short)0, 0, 1));
+ assertEquals((short)0x1FDC, Conversion.hexToShort(src, 0, (short)0, 0, 4));
+ assertEquals((short)0xF1FD, Conversion.hexToShort(src, 1, (short)0, 0, 4));
+ assertEquals((short)0x1234, Conversion.hexToShort(src, 0, (short)0x1234, 0, 0));
+ assertEquals((short)0x8764, Conversion.hexToShort(src, 15, (short)0x1234, 4, 3));
}
/**
- * Tests {@link Conversion#hexsToByte(String, int, byte, int, int)}.
+ * Tests {@link Conversion#hexToByte(String, int, byte, int, int)}.
*/
@Test
- public void testHexsToByte() {
+ public void testHexToByte() {
String src = "CDF1F0C10F12345678";
- assertEquals((byte)0x00, Conversion.hexsToByte(src, 0, (byte)0, 0, 0));
- assertEquals((byte)0x0C, Conversion.hexsToByte(src, 0, (byte)0, 0, 1));
- assertEquals((byte)0xDC, Conversion.hexsToByte(src, 0, (byte)0, 0, 2));
- assertEquals((byte)0xFD, Conversion.hexsToByte(src, 1, (byte)0, 0, 2));
- assertEquals((byte)0x34, Conversion.hexsToByte(src, 0, (byte)0x34, 0, 0));
- assertEquals((byte)0x84, Conversion.hexsToByte(src, 17, (byte)0x34, 4, 1));
+ assertEquals((byte)0x00, Conversion.hexToByte(src, 0, (byte)0, 0, 0));
+ assertEquals((byte)0x0C, Conversion.hexToByte(src, 0, (byte)0, 0, 1));
+ assertEquals((byte)0xDC, Conversion.hexToByte(src, 0, (byte)0, 0, 2));
+ assertEquals((byte)0xFD, Conversion.hexToByte(src, 1, (byte)0, 0, 2));
+ assertEquals((byte)0x34, Conversion.hexToByte(src, 0, (byte)0x34, 0, 0));
+ assertEquals((byte)0x84, Conversion.hexToByte(src, 17, (byte)0x34, 4, 1));
}
/**
- * Tests {@link Conversion#boolsToLong(boolean[], int, long, int, int)}.
+ * Tests {@link Conversion#boolArrayToLong(boolean[], int, long, int, int)}.
*/
@Test
- public void testBoolsToLong() {
+ public void testBoolArrayToLong() {
boolean[] src = new boolean[]{
false, false, true, true, true, false, true, true, true, true, true, true, true,
false, false, false, true, true, true, true, false, false, false, false, false,
@@ -711,23 +747,23 @@ public class ConversionTest {
true, true, true, true, false, false, false, false, true, false, false, true, true,
false, false, false, false, true, false, true, false, true, false, false, true,
true, false, true, true, true, false, false, false, false, true};
- // conversion of "CDF1F0C10F12345678" by hexsToBools
- assertEquals(0x0000000000000000L, Conversion.boolsToLong(src, 0, 0L, 0, 0));
- assertEquals(0x000000000000000CL, Conversion.boolsToLong(src, 0, 0L, 0, 1 * 4));
- assertEquals(0x000000001C0F1FDCL, Conversion.boolsToLong(src, 0, 0L, 0, 8 * 4));
- assertEquals(0x0000000001C0F1FDL, Conversion.boolsToLong(src, 1 * 4, 0L, 0, 8 * 4));
+ // conversion of "CDF1F0C10F12345678" by HexToBoolArray
+ assertEquals(0x0000000000000000L, Conversion.boolArrayToLong(src, 0, 0L, 0, 0));
+ assertEquals(0x000000000000000CL, Conversion.boolArrayToLong(src, 0, 0L, 0, 1 * 4));
+ assertEquals(0x000000001C0F1FDCL, Conversion.boolArrayToLong(src, 0, 0L, 0, 8 * 4));
+ assertEquals(0x0000000001C0F1FDL, Conversion.boolArrayToLong(src, 1 * 4, 0L, 0, 8 * 4));
assertEquals(
- 0x123456798ABCDEF0L, Conversion.boolsToLong(src, 0, 0x123456798ABCDEF0L, 0, 0));
+ 0x123456798ABCDEF0L, Conversion.boolArrayToLong(src, 0, 0x123456798ABCDEF0L, 0, 0));
assertEquals(
0x1234567876BCDEF0L,
- Conversion.boolsToLong(src, 15 * 4, 0x123456798ABCDEF0L, 24, 3 * 4));
+ Conversion.boolArrayToLong(src, 15 * 4, 0x123456798ABCDEF0L, 24, 3 * 4));
}
/**
- * Tests {@link Conversion#boolsToInt(boolean[], int, int, int, int)}.
+ * Tests {@link Conversion#boolArrayToInt(boolean[], int, int, int, int)}.
*/
@Test
- public void testBoolsToInt() {
+ public void testBoolArrayToInt() {
boolean[] src = new boolean[]{
false, false, true, true, true, false, true, true, true, true, true, true, true,
false, false, false, true, true, true, true, false, false, false, false, false,
@@ -735,20 +771,20 @@ public class ConversionTest {
true, true, true, true, false, false, false, false, true, false, false, true, true,
false, false, false, false, true, false, true, false, true, false, false, true,
true, false, true, true, true, false, false, false, false, true};
- // conversion of "CDF1F0C10F12345678" by hexsToBools
- assertEquals(0x00000000, Conversion.boolsToInt(src, 0 * 4, 0, 0, 0 * 4));
- assertEquals(0x0000000C, Conversion.boolsToInt(src, 0 * 4, 0, 0, 1 * 4));
- assertEquals(0x1C0F1FDC, Conversion.boolsToInt(src, 0 * 4, 0, 0, 8 * 4));
- assertEquals(0x01C0F1FD, Conversion.boolsToInt(src, 1 * 4, 0, 0, 8 * 4));
- assertEquals(0x12345679, Conversion.boolsToInt(src, 0 * 4, 0x12345679, 0, 0 * 4));
- assertEquals(0x87645679, Conversion.boolsToInt(src, 15 * 4, 0x12345679, 20, 3 * 4));
+ // conversion of "CDF1F0C10F12345678" by HexToBoolArray
+ assertEquals(0x00000000, Conversion.boolArrayToInt(src, 0 * 4, 0, 0, 0 * 4));
+ assertEquals(0x0000000C, Conversion.boolArrayToInt(src, 0 * 4, 0, 0, 1 * 4));
+ assertEquals(0x1C0F1FDC, Conversion.boolArrayToInt(src, 0 * 4, 0, 0, 8 * 4));
+ assertEquals(0x01C0F1FD, Conversion.boolArrayToInt(src, 1 * 4, 0, 0, 8 * 4));
+ assertEquals(0x12345679, Conversion.boolArrayToInt(src, 0 * 4, 0x12345679, 0, 0 * 4));
+ assertEquals(0x87645679, Conversion.boolArrayToInt(src, 15 * 4, 0x12345679, 20, 3 * 4));
}
/**
- * Tests {@link Conversion#boolsToShort(boolean[], int, short, int, int)}.
+ * Tests {@link Conversion#boolArrayToShort(boolean[], int, short, int, int)}.
*/
@Test
- public void testBoolsToShort() {
+ public void testBoolArrayToShort() {
boolean[] src = new boolean[]{
false, false, true, true, true, false, true, true, true, true, true, true, true,
false, false, false, true, true, true, true, false, false, false, false, false,
@@ -756,22 +792,22 @@ public class ConversionTest {
true, true, true, true, false, false, false, false, true, false, false, true, true,
false, false, false, false, true, false, true, false, true, false, false, true,
true, false, true, true, true, false, false, false, false, true};
- // conversion of "CDF1F0C10F12345678" by hexsToBools
- assertEquals((short)0x0000, Conversion.boolsToShort(src, 0 * 4, (short)0, 0, 0 * 4));
- assertEquals((short)0x000C, Conversion.boolsToShort(src, 0 * 4, (short)0, 0, 1 * 4));
- assertEquals((short)0x1FDC, Conversion.boolsToShort(src, 0 * 4, (short)0, 0, 4 * 4));
- assertEquals((short)0xF1FD, Conversion.boolsToShort(src, 1 * 4, (short)0, 0, 4 * 4));
+ // conversion of "CDF1F0C10F12345678" by HexToBoolArray
+ assertEquals((short)0x0000, Conversion.boolArrayToShort(src, 0 * 4, (short)0, 0, 0 * 4));
+ assertEquals((short)0x000C, Conversion.boolArrayToShort(src, 0 * 4, (short)0, 0, 1 * 4));
+ assertEquals((short)0x1FDC, Conversion.boolArrayToShort(src, 0 * 4, (short)0, 0, 4 * 4));
+ assertEquals((short)0xF1FD, Conversion.boolArrayToShort(src, 1 * 4, (short)0, 0, 4 * 4));
assertEquals(
- (short)0x1234, Conversion.boolsToShort(src, 0 * 4, (short)0x1234, 0, 0 * 4));
+ (short)0x1234, Conversion.boolArrayToShort(src, 0 * 4, (short)0x1234, 0, 0 * 4));
assertEquals(
- (short)0x8764, Conversion.boolsToShort(src, 15 * 4, (short)0x1234, 4, 3 * 4));
+ (short)0x8764, Conversion.boolArrayToShort(src, 15 * 4, (short)0x1234, 4, 3 * 4));
}
/**
- * Tests {@link Conversion#boolsToByte(boolean[], int, byte, int, int)}.
+ * Tests {@link Conversion#boolArrayToByte(boolean[], int, byte, int, int)}.
*/
@Test
- public void testBoolsToByte() {
+ public void testBoolArrayToByte() {
boolean[] src = new boolean[]{
false, false, true, true, true, false, true, true, true, true, true, true, true,
false, false, false, true, true, true, true, false, false, false, false, false,
@@ -779,636 +815,684 @@ public class ConversionTest {
true, true, true, true, false, false, false, false, true, false, false, true, true,
false, false, false, false, true, false, true, false, true, false, false, true,
true, false, true, true, true, false, false, false, false, true};
- // conversion of "CDF1F0C10F12345678" by hexsToBools
- assertEquals((byte)0x00, Conversion.boolsToByte(src, 0 * 4, (byte)0, 0, 0 * 4));
- assertEquals((byte)0x0C, Conversion.boolsToByte(src, 0 * 4, (byte)0, 0, 1 * 4));
- assertEquals((byte)0xDC, Conversion.boolsToByte(src, 0 * 4, (byte)0, 0, 2 * 4));
- assertEquals((byte)0xFD, Conversion.boolsToByte(src, 1 * 4, (byte)0, 0, 2 * 4));
- assertEquals((byte)0x34, Conversion.boolsToByte(src, 0 * 4, (byte)0x34, 0, 0 * 4));
- assertEquals((byte)0x84, Conversion.boolsToByte(src, 17 * 4, (byte)0x34, 4, 1 * 4));
+ // conversion of "CDF1F0C10F12345678" by HexToBoolArray
+ assertEquals((byte)0x00, Conversion.boolArrayToByte(src, 0 * 4, (byte)0, 0, 0 * 4));
+ assertEquals((byte)0x0C, Conversion.boolArrayToByte(src, 0 * 4, (byte)0, 0, 1 * 4));
+ assertEquals((byte)0xDC, Conversion.boolArrayToByte(src, 0 * 4, (byte)0, 0, 2 * 4));
+ assertEquals((byte)0xFD, Conversion.boolArrayToByte(src, 1 * 4, (byte)0, 0, 2 * 4));
+ assertEquals((byte)0x34, Conversion.boolArrayToByte(src, 0 * 4, (byte)0x34, 0, 0 * 4));
+ assertEquals((byte)0x84, Conversion.boolArrayToByte(src, 17 * 4, (byte)0x34, 4, 1 * 4));
}
/**
- * Tests {@link Conversion#longToInts(long, int, int[], int, int)}.
+ * Tests {@link Conversion#longToIntArray(long, int, int[], int, int)}.
*/
@Test
- public void testLongToInts() {
+ public void testLongToIntArray() {
assertArrayEquals(
- new int[]{}, Conversion.longToInts(0x0000000000000000L, 0, new int[]{}, 0, 0));
+ new int[]{}, Conversion.longToIntArray(0x0000000000000000L, 0, new int[]{}, 0, 0));
assertArrayEquals(
- new int[]{}, Conversion.longToInts(0x0000000000000000L, 100, new int[]{}, 0, 0));
+ new int[]{}, Conversion.longToIntArray(0x0000000000000000L, 100, new int[]{}, 0, 0));
assertArrayEquals(
- new int[]{}, Conversion.longToInts(0x0000000000000000L, 0, new int[]{}, 100, 0));
+ new int[]{}, Conversion.longToIntArray(0x0000000000000000L, 0, new int[]{}, 100, 0));
assertArrayEquals(
new int[]{0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF},
- Conversion.longToInts(0x1234567890ABCDEFL, 0, new int[]{-1, -1, -1, -1}, 0, 0));
+ Conversion.longToIntArray(0x1234567890ABCDEFL, 0, new int[]{-1, -1, -1, -1}, 0, 0));
assertArrayEquals(
new int[]{0x90ABCDEF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF},
- Conversion.longToInts(0x1234567890ABCDEFL, 0, new int[]{-1, -1, -1, -1}, 0, 1));
+ Conversion.longToIntArray(0x1234567890ABCDEFL, 0, new int[]{-1, -1, -1, -1}, 0, 1));
assertArrayEquals(
new int[]{0x90ABCDEF, 0x12345678, 0xFFFFFFFF, 0xFFFFFFFF},
- Conversion.longToInts(0x1234567890ABCDEFL, 0, new int[]{-1, -1, -1, -1}, 0, 2));
+ Conversion.longToIntArray(0x1234567890ABCDEFL, 0, new int[]{-1, -1, -1, -1}, 0, 2));
// assertArrayEquals(new
- // int[]{0x90ABCDEF,0x12345678,0x90ABCDEF,0x12345678},Conversion.longToInts(0x1234567890ABCDEFL,
+ // int[]{0x90ABCDEF,0x12345678,0x90ABCDEF,0x12345678},Conversion.longToIntArray(0x1234567890ABCDEFL,
// 0,new int[]{-1,-1,-1,-1},0,4));//rejected by assertion
// assertArrayEquals(new
- // int[]{0xFFFFFFFF,0x90ABCDEF,0x12345678,0x90ABCDEF},Conversion.longToInts(0x1234567890ABCDEFL,
+ // int[]{0xFFFFFFFF,0x90ABCDEF,0x12345678,0x90ABCDEF},Conversion.longToIntArray(0x1234567890ABCDEFL,
// 0,new int[]{-1,-1,-1,-1},1,3));
assertArrayEquals(
new int[]{0xFFFFFFFF, 0xFFFFFFFF, 0x90ABCDEF, 0x12345678},
- Conversion.longToInts(0x1234567890ABCDEFL, 0, new int[]{-1, -1, -1, -1}, 2, 2));
+ Conversion.longToIntArray(0x1234567890ABCDEFL, 0, new int[]{-1, -1, -1, -1}, 2, 2));
assertArrayEquals(
new int[]{0xFFFFFFFF, 0xFFFFFFFF, 0x90ABCDEF, 0xFFFFFFFF},
- Conversion.longToInts(0x1234567890ABCDEFL, 0, new int[]{-1, -1, -1, -1}, 2, 1));
+ Conversion.longToIntArray(0x1234567890ABCDEFL, 0, new int[]{-1, -1, -1, -1}, 2, 1));
assertArrayEquals(
new int[]{0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x90ABCDEF},
- Conversion.longToInts(0x1234567890ABCDEFL, 0, new int[]{-1, -1, -1, -1}, 3, 1));
+ Conversion.longToIntArray(0x1234567890ABCDEFL, 0, new int[]{-1, -1, -1, -1}, 3, 1));
assertArrayEquals(
new int[]{0xFFFFFFFF, 0xFFFFFFFF, 0x4855E6F7, 0xFFFFFFFF},
- Conversion.longToInts(0x1234567890ABCDEFL, 1, new int[]{-1, -1, -1, -1}, 2, 1));
+ Conversion.longToIntArray(0x1234567890ABCDEFL, 1, new int[]{-1, -1, -1, -1}, 2, 1));
assertArrayEquals(
new int[]{0xFFFFFFFF, 0xFFFFFFFF, 0x242AF37B, 0xFFFFFFFF},
- Conversion.longToInts(0x1234567890ABCDEFL, 2, new int[]{-1, -1, -1, -1}, 2, 1));
+ Conversion.longToIntArray(0x1234567890ABCDEFL, 2, new int[]{-1, -1, -1, -1}, 2, 1));
assertArrayEquals(
new int[]{0xFFFFFFFF, 0xFFFFFFFF, 0x121579BD, 0xFFFFFFFF},
- Conversion.longToInts(0x1234567890ABCDEFL, 3, new int[]{-1, -1, -1, -1}, 2, 1));
+ Conversion.longToIntArray(0x1234567890ABCDEFL, 3, new int[]{-1, -1, -1, -1}, 2, 1));
assertArrayEquals(
new int[]{0xFFFFFFFF, 0xFFFFFFFF, 0x890ABCDE, 0xFFFFFFFF},
- Conversion.longToInts(0x1234567890ABCDEFL, 4, new int[]{-1, -1, -1, -1}, 2, 1));
+ Conversion.longToIntArray(0x1234567890ABCDEFL, 4, new int[]{-1, -1, -1, -1}, 2, 1));
// assertArrayEquals(new
- // int[]{0x4855E6F7,0x091A2B3C,0x4855E6F7,0x091A2B3C},Conversion.longToInts(0x1234567890ABCDEFL,
+ // int[]{0x4855E6F7,0x091A2B3C,0x4855E6F7,0x091A2B3C},Conversion.longToIntArray(0x1234567890ABCDEFL,
// 1,new int[]{-1,-1,-1,-1},0,4));//rejected by assertion
assertArrayEquals(
new int[]{0x091A2B3C},
- Conversion.longToInts(0x1234567890ABCDEFL, 33, new int[]{0}, 0, 1));
+ Conversion.longToIntArray(0x1234567890ABCDEFL, 33, new int[]{0}, 0, 1));
}
/**
- * Tests {@link Conversion#longToShorts(long, int, short[], int, int)}.
+ * Tests {@link Conversion#longToShortArray(long, int, short[], int, int)}.
*/
@Test
- public void testLongToShorts() {
+ public void testLongToShortArray() {
assertArrayEquals(
- new short[]{}, Conversion.longToShorts(0x0000000000000000L, 0, new short[]{}, 0, 0));
+ new short[]{},
+ Conversion.longToShortArray(0x0000000000000000L, 0, new short[]{}, 0, 0));
assertArrayEquals(
new short[]{},
- Conversion.longToShorts(0x0000000000000000L, 100, new short[]{}, 0, 0));
+ Conversion.longToShortArray(0x0000000000000000L, 100, new short[]{}, 0, 0));
assertArrayEquals(
new short[]{},
- Conversion.longToShorts(0x0000000000000000L, 0, new short[]{}, 100, 0));
+ Conversion.longToShortArray(0x0000000000000000L, 0, new short[]{}, 100, 0));
assertArrayEquals(
new short[]{(short)0xFFFF, (short)0xFFFF, (short)0xFFFF, (short)0xFFFF},
- Conversion.longToShorts(0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 0, 0));
+ Conversion.longToShortArray(
+ 0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 0, 0));
assertArrayEquals(
new short[]{(short)0xCDEF, (short)0xFFFF, (short)0xFFFF, (short)0xFFFF},
- Conversion.longToShorts(0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 0, 1));
+ Conversion.longToShortArray(
+ 0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 0, 1));
assertArrayEquals(
new short[]{(short)0xCDEF, (short)0x90AB, (short)0xFFFF, (short)0xFFFF},
- Conversion.longToShorts(0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 0, 2));
+ Conversion.longToShortArray(
+ 0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 0, 2));
assertArrayEquals(
new short[]{(short)0xCDEF, (short)0x90AB, (short)0x5678, (short)0xFFFF},
- Conversion.longToShorts(0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 0, 3));
+ Conversion.longToShortArray(
+ 0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 0, 3));
assertArrayEquals(
new short[]{(short)0xCDEF, (short)0x90AB, (short)0x5678, (short)0x1234},
- Conversion.longToShorts(0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 0, 4));
+ Conversion.longToShortArray(
+ 0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 0, 4));
assertArrayEquals(
new short[]{(short)0xFFFF, (short)0xCDEF, (short)0x90AB, (short)0x5678},
- Conversion.longToShorts(0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 1, 3));
+ Conversion.longToShortArray(
+ 0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 1, 3));
assertArrayEquals(
new short[]{(short)0xFFFF, (short)0xFFFF, (short)0xCDEF, (short)0x90AB},
- Conversion.longToShorts(0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 2, 2));
+ Conversion.longToShortArray(
+ 0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 2, 2));
assertArrayEquals(
new short[]{(short)0xFFFF, (short)0xFFFF, (short)0xCDEF, (short)0xFFFF},
- Conversion.longToShorts(0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 2, 1));
+ Conversion.longToShortArray(
+ 0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 2, 1));
assertArrayEquals(
new short[]{(short)0xFFFF, (short)0xFFFF, (short)0xFFFF, (short)0xCDEF},
- Conversion.longToShorts(0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 3, 1));
+ Conversion.longToShortArray(
+ 0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 3, 1));
assertArrayEquals(
new short[]{(short)0xFFFF, (short)0xFFFF, (short)0xE6F7, (short)0xFFFF},
- Conversion.longToShorts(0x1234567890ABCDEFL, 1, new short[]{-1, -1, -1, -1}, 2, 1));
+ Conversion.longToShortArray(
+ 0x1234567890ABCDEFL, 1, new short[]{-1, -1, -1, -1}, 2, 1));
assertArrayEquals(
new short[]{(short)0xFFFF, (short)0xFFFF, (short)0xF37B, (short)0xFFFF},
- Conversion.longToShorts(0x1234567890ABCDEFL, 2, new short[]{-1, -1, -1, -1}, 2, 1));
+ Conversion.longToShortArray(
+ 0x1234567890ABCDEFL, 2, new short[]{-1, -1, -1, -1}, 2, 1));
assertArrayEquals(
new short[]{(short)0xFFFF, (short)0xFFFF, (short)0x79BD, (short)0xFFFF},
- Conversion.longToShorts(0x1234567890ABCDEFL, 3, new short[]{-1, -1, -1, -1}, 2, 1));
+ Conversion.longToShortArray(
+ 0x1234567890ABCDEFL, 3, new short[]{-1, -1, -1, -1}, 2, 1));
assertArrayEquals(
new short[]{(short)0xFFFF, (short)0xFFFF, (short)0xBCDE, (short)0xFFFF},
- Conversion.longToShorts(0x1234567890ABCDEFL, 4, new short[]{-1, -1, -1, -1}, 2, 1));
+ Conversion.longToShortArray(
+ 0x1234567890ABCDEFL, 4, new short[]{-1, -1, -1, -1}, 2, 1));
assertArrayEquals(
new short[]{(short)0xE6F7, (short)0x4855, (short)0x2B3C, (short)0x091A},
- Conversion.longToShorts(0x1234567890ABCDEFL, 1, new short[]{-1, -1, -1, -1}, 0, 4));
+ Conversion.longToShortArray(
+ 0x1234567890ABCDEFL, 1, new short[]{-1, -1, -1, -1}, 0, 4));
assertArrayEquals(
new short[]{(short)0x2B3C},
- Conversion.longToShorts(0x1234567890ABCDEFL, 33, new short[]{0}, 0, 1));
+ Conversion.longToShortArray(0x1234567890ABCDEFL, 33, new short[]{0}, 0, 1));
}
/**
- * Tests {@link Conversion#intToShorts(int, int, short[], int, int)}.
+ * Tests {@link Conversion#intToShortArray(int, int, short[], int, int)}.
*/
@Test
- public void testIntToShorts() {
+ public void testIntToShortArray() {
assertArrayEquals(
- new short[]{}, Conversion.intToShorts(0x00000000, 0, new short[]{}, 0, 0));
+ new short[]{}, Conversion.intToShortArray(0x00000000, 0, new short[]{}, 0, 0));
assertArrayEquals(
- new short[]{}, Conversion.intToShorts(0x00000000, 100, new short[]{}, 0, 0));
+ new short[]{}, Conversion.intToShortArray(0x00000000, 100, new short[]{}, 0, 0));
assertArrayEquals(
- new short[]{}, Conversion.intToShorts(0x00000000, 0, new short[]{}, 100, 0));
+ new short[]{}, Conversion.intToShortArray(0x00000000, 0, new short[]{}, 100, 0));
assertArrayEquals(
new short[]{(short)0xFFFF, (short)0xFFFF, (short)0xFFFF, (short)0xFFFF},
- Conversion.intToShorts(0x12345678, 0, new short[]{-1, -1, -1, -1}, 0, 0));
+ Conversion.intToShortArray(0x12345678, 0, new short[]{-1, -1, -1, -1}, 0, 0));
assertArrayEquals(
new short[]{(short)0x5678, (short)0xFFFF, (short)0xFFFF, (short)0xFFFF},
- Conversion.intToShorts(0x12345678, 0, new short[]{-1, -1, -1, -1}, 0, 1));
+ Conversion.intToShortArray(0x12345678, 0, new short[]{-1, -1, -1, -1}, 0, 1));
assertArrayEquals(
new short[]{(short)0x5678, (short)0x1234, (short)0xFFFF, (short)0xFFFF},
- Conversion.intToShorts(0x12345678, 0, new short[]{-1, -1, -1, -1}, 0, 2));
+ Conversion.intToShortArray(0x12345678, 0, new short[]{-1, -1, -1, -1}, 0, 2));
// assertArrayEquals(new
- // short[]{(short)0x5678,(short)0x1234,(short)0x5678,(short)0xFFFF},Conversion.intToShorts(0x12345678,
+ // short[]{(short)0x5678,(short)0x1234,(short)0x5678,(short)0xFFFF},Conversion.intToShortArray(0x12345678,
// 0,new short[]{-1,-1,-1,-1},0,3));//rejected by assertion
// assertArrayEquals(new
- // short[]{(short)0x5678,(short)0x1234,(short)0x5678,(short)0x1234},Conversion.intToShorts(0x12345678,
+ // short[]{(short)0x5678,(short)0x1234,(short)0x5678,(short)0x1234},Conversion.intToShortArray(0x12345678,
// 0,new short[]{-1,-1,-1,-1},0,4));
// assertArrayEquals(new
- // short[]{(short)0xFFFF,(short)0x5678,(short)0x1234,(short)0x5678},Conversion.intToShorts(0x12345678,
+ // short[]{(short)0xFFFF,(short)0x5678,(short)0x1234,(short)0x5678},Conversion.intToShortArray(0x12345678,
// 0,new short[]{-1,-1,-1,-1},1,3));
assertArrayEquals(
new short[]{(short)0xFFFF, (short)0xFFFF, (short)0x5678, (short)0x1234},
- Conversion.intToShorts(0x12345678, 0, new short[]{-1, -1, -1, -1}, 2, 2));
+ Conversion.intToShortArray(0x12345678, 0, new short[]{-1, -1, -1, -1}, 2, 2));
assertArrayEquals(
new short[]{(short)0xFFFF, (short)0xFFFF, (short)0x5678, (short)0xFFFF},
- Conversion.intToShorts(0x12345678, 0, new short[]{-1, -1, -1, -1}, 2, 1));
+ Conversion.intToShortArray(0x12345678, 0, new short[]{-1, -1, -1, -1}, 2, 1));
assertArrayEquals(
new short[]{(short)0xFFFF, (short)0xFFFF, (short)0xFFFF, (short)0x5678},
- Conversion.intToShorts(0x12345678, 0, new short[]{-1, -1, -1, -1}, 3, 1));
+ Conversion.intToShortArray(0x12345678, 0, new short[]{-1, -1, -1, -1}, 3, 1));
assertArrayEquals(
new short[]{(short)0xFFFF, (short)0xFFFF, (short)0x2B3C, (short)0xFFFF},
- Conversion.intToShorts(0x12345678, 1, new short[]{-1, -1, -1, -1}, 2, 1));
+ Conversion.intToShortArray(0x12345678, 1, new short[]{-1, -1, -1, -1}, 2, 1));
assertArrayEquals(
new short[]{(short)0xFFFF, (short)0xFFFF, (short)0x159E, (short)0xFFFF},
- Conversion.intToShorts(0x12345678, 2, new short[]{-1, -1, -1, -1}, 2, 1));
+ Conversion.intToShortArray(0x12345678, 2, new short[]{-1, -1, -1, -1}, 2, 1));
assertArrayEquals(
new short[]{(short)0xFFFF, (short)0xFFFF, (short)0x8ACF, (short)0xFFFF},
- Conversion.intToShorts(0x12345678, 3, new short[]{-1, -1, -1, -1}, 2, 1));
+ Conversion.intToShortArray(0x12345678, 3, new short[]{-1, -1, -1, -1}, 2, 1));
assertArrayEquals(
new short[]{(short)0xFFFF, (short)0xFFFF, (short)0x4567, (short)0xFFFF},
- Conversion.intToShorts(0x12345678, 4, new short[]{-1, -1, -1, -1}, 2, 1));
+ Conversion.intToShortArray(0x12345678, 4, new short[]{-1, -1, -1, -1}, 2, 1));
// assertArrayEquals(new
- // short[]{(short)0xE6F7,(short)0x4855,(short)0x2B3C,(short)0x091A},Conversion.intToShorts(0x12345678,
+ // short[]{(short)0xE6F7,(short)0x4855,(short)0x2B3C,(short)0x091A},Conversion.intToShortArray(0x12345678,
// 1,new short[]{-1,-1,-1,-1},0,4));//rejected by assertion
- // assertArrayEquals(new short[]{(short)0x2B3C},Conversion.intToShorts(0x12345678,33,new
+ // assertArrayEquals(new
+ // short[]{(short)0x2B3C},Conversion.intToShortArray(0x12345678,33,new
// short[]{0},0,1));//rejected by assertion
assertArrayEquals(
new short[]{(short)0x091A},
- Conversion.intToShorts(0x12345678, 17, new short[]{0}, 0, 1));
+ Conversion.intToShortArray(0x12345678, 17, new short[]{0}, 0, 1));
}
/**
- * Tests {@link Conversion#longToBytes(long, int, byte[], int, int)}.
+ * Tests {@link Conversion#longToByteArray(long, int, byte[], int, int)}.
*/
@Test
- public void testLongToBytes() {
+ public void testLongToByteArray() {
assertArrayEquals(
- new byte[]{}, Conversion.longToBytes(0x0000000000000000L, 0, new byte[]{}, 0, 0));
+ new byte[]{},
+ Conversion.longToByteArray(0x0000000000000000L, 0, new byte[]{}, 0, 0));
assertArrayEquals(
- new byte[]{}, Conversion.longToBytes(0x0000000000000000L, 100, new byte[]{}, 0, 0));
+ new byte[]{},
+ Conversion.longToByteArray(0x0000000000000000L, 100, new byte[]{}, 0, 0));
assertArrayEquals(
- new byte[]{}, Conversion.longToBytes(0x0000000000000000L, 0, new byte[]{}, 100, 0));
+ new byte[]{},
+ Conversion.longToByteArray(0x0000000000000000L, 0, new byte[]{}, 100, 0));
assertArrayEquals(
new byte[]{
(byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF,
(byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF},
- Conversion.longToBytes(0x1234567890ABCDEFL, 0, new byte[]{
+ Conversion.longToByteArray(0x1234567890ABCDEFL, 0, new byte[]{
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 0, 0));
assertArrayEquals(
new byte[]{
(byte)0xEF, (byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF,
(byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF},
- Conversion.longToBytes(0x1234567890ABCDEFL, 0, new byte[]{
+ Conversion.longToByteArray(0x1234567890ABCDEFL, 0, new byte[]{
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 0, 1));
assertArrayEquals(
new byte[]{
(byte)0xEF, (byte)0xCD, (byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF,
(byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF},
- Conversion.longToBytes(0x1234567890ABCDEFL, 0, new byte[]{
+ Conversion.longToByteArray(0x1234567890ABCDEFL, 0, new byte[]{
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 0, 2));
assertArrayEquals(
new byte[]{
(byte)0xEF, (byte)0xCD, (byte)0xAB, (byte)0x90, (byte)0xFF, (byte)0xFF,
(byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF},
- Conversion.longToBytes(0x1234567890ABCDEFL, 0, new byte[]{
+ Conversion.longToByteArray(0x1234567890ABCDEFL, 0, new byte[]{
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 0, 4));
assertArrayEquals(
new byte[]{
(byte)0xEF, (byte)0xCD, (byte)0xAB, (byte)0x90, (byte)0x78, (byte)0x56,
(byte)0x34, (byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF},
- Conversion.longToBytes(0x1234567890ABCDEFL, 0, new byte[]{
+ Conversion.longToByteArray(0x1234567890ABCDEFL, 0, new byte[]{
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 0, 7));
assertArrayEquals(
new byte[]{
(byte)0xEF, (byte)0xCD, (byte)0xAB, (byte)0x90, (byte)0x78, (byte)0x56,
(byte)0x34, (byte)0x12, (byte)0xFF, (byte)0xFF, (byte)0xFF},
- Conversion.longToBytes(0x1234567890ABCDEFL, 0, new byte[]{
+ Conversion.longToByteArray(0x1234567890ABCDEFL, 0, new byte[]{
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 0, 8));
assertArrayEquals(
new byte[]{
(byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xEF, (byte)0xFF, (byte)0xFF,
(byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF},
- Conversion.longToBytes(0x1234567890ABCDEFL, 0, new byte[]{
+ Conversion.longToByteArray(0x1234567890ABCDEFL, 0, new byte[]{
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 3, 1));
assertArrayEquals(
new byte[]{
(byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xEF, (byte)0xCD, (byte)0xFF,
(byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF},
- Conversion.longToBytes(0x1234567890ABCDEFL, 0, new byte[]{
+ Conversion.longToByteArray(0x1234567890ABCDEFL, 0, new byte[]{
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 3, 2));
assertArrayEquals(
new byte[]{
(byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xEF, (byte)0xCD, (byte)0xAB,
(byte)0x90, (byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF},
- Conversion.longToBytes(0x1234567890ABCDEFL, 0, new byte[]{
+ Conversion.longToByteArray(0x1234567890ABCDEFL, 0, new byte[]{
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 3, 4));
assertArrayEquals(
new byte[]{
(byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xEF, (byte)0xCD, (byte)0xAB,
(byte)0x90, (byte)0x78, (byte)0x56, (byte)0x34, (byte)0xFF},
- Conversion.longToBytes(0x1234567890ABCDEFL, 0, new byte[]{
+ Conversion.longToByteArray(0x1234567890ABCDEFL, 0, new byte[]{
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 3, 7));
assertArrayEquals(
new byte[]{
(byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xEF, (byte)0xCD, (byte)0xAB,
(byte)0x90, (byte)0x78, (byte)0x56, (byte)0x34, (byte)0x12},
- Conversion.longToBytes(0x1234567890ABCDEFL, 0, new byte[]{
+ Conversion.longToByteArray(0x1234567890ABCDEFL, 0, new byte[]{
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 3, 8));
assertArrayEquals(
new byte[]{
(byte)0xF7, (byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF,
(byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF},
- Conversion.longToBytes(0x1234567890ABCDEFL, 1, new byte[]{
+ Conversion.longToByteArray(0x1234567890ABCDEFL, 1, new byte[]{
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 0, 1));
assertArrayEquals(
new byte[]{
(byte)0x7B, (byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF,
(byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF},
- Conversion.longToBytes(0x1234567890ABCDEFL, 2, new byte[]{
+ Conversion.longToByteArray(0x1234567890ABCDEFL, 2, new byte[]{
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 0, 1));
assertArrayEquals(
new byte[]{
(byte)0xFF, (byte)0x00, (byte)0xFF, (byte)0x6F, (byte)0x5E, (byte)0x85,
(byte)0xC4, (byte)0xB3, (byte)0xA2, (byte)0x91, (byte)0x00},
- Conversion.longToBytes(0x1234567890ABCDEFL, 5, new byte[]{
+ Conversion.longToByteArray(0x1234567890ABCDEFL, 5, new byte[]{
-1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 3, 8));
// assertArrayEquals(new
- // byte[]{(byte)0xFF,(byte)0x00,(byte)0xFF,(byte)0x5E,(byte)0x85,(byte)0xC4,(byte)0xB3,(byte)0xA2,(byte)0x91,(byte)0x00,(byte)0x00},Conversion.longToBytes(0x1234567890ABCDEFL,13,new
+ // byte[]{(byte)0xFF,(byte)0x00,(byte)0xFF,(byte)0x5E,(byte)0x85,(byte)0xC4,(byte)0xB3,(byte)0xA2,(byte)0x91,(byte)0x00,(byte)0x00},Conversion.longToByteArray(0x1234567890ABCDEFL,13,new
// byte[]{-1, 0,-1,-1,-1,-1,-1,-1,-1,-1,-1},3,8));//rejected by assertion
assertArrayEquals(
new byte[]{
(byte)0xFF, (byte)0x00, (byte)0xFF, (byte)0x5E, (byte)0x85, (byte)0xC4,
(byte)0xB3, (byte)0xA2, (byte)0x91, (byte)0x00, (byte)0xFF},
- Conversion.longToBytes(0x1234567890ABCDEFL, 13, new byte[]{
+ Conversion.longToByteArray(0x1234567890ABCDEFL, 13, new byte[]{
-1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 3, 7));
}
/**
- * Tests {@link Conversion#intToBytes(int, int, byte[], int, int)}.
+ * Tests {@link Conversion#intToByteArray(int, int, byte[], int, int)}.
*/
@Test
- public void testIntToBytes() {
+ public void testIntToByteArray() {
assertArrayEquals(
[... 886 lines stripped ...]