• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements.  See the NOTICE file distributed with
4  * this work for additional information regarding copyright ownership.
5  * The ASF licenses this file to You under the Apache License, Version 2.0
6  * (the "License"); you may not use this file except in compliance with
7  * the License.  You may obtain a copy of the License at
8  *
9  *      http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 package org.apache.commons.lang3;
18 
19 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
20 import static org.junit.jupiter.api.Assertions.assertEquals;
21 import static org.junit.jupiter.api.Assertions.assertThrows;
22 
23 import java.util.Arrays;
24 import java.util.SplittableRandom;
25 import java.util.UUID;
26 
27 import org.junit.jupiter.api.Test;
28 import org.junit.jupiter.params.ParameterizedTest;
29 import org.junit.jupiter.params.provider.ValueSource;
30 
31 
32 /**
33  * Unit tests {@link Conversion}.
34  */
35 public class ConversionTest extends AbstractLangTest {
36 
37     /**
38      * Tests {@link Conversion#hexDigitToInt(char)}.
39      */
40     @Test
testHexDigitToInt()41     public void testHexDigitToInt() {
42         assertEquals(0, Conversion.hexDigitToInt('0'));
43         assertEquals(1, Conversion.hexDigitToInt('1'));
44         assertEquals(2, Conversion.hexDigitToInt('2'));
45         assertEquals(3, Conversion.hexDigitToInt('3'));
46         assertEquals(4, Conversion.hexDigitToInt('4'));
47         assertEquals(5, Conversion.hexDigitToInt('5'));
48         assertEquals(6, Conversion.hexDigitToInt('6'));
49         assertEquals(7, Conversion.hexDigitToInt('7'));
50         assertEquals(8, Conversion.hexDigitToInt('8'));
51         assertEquals(9, Conversion.hexDigitToInt('9'));
52         assertEquals(10, Conversion.hexDigitToInt('A'));
53         assertEquals(10, Conversion.hexDigitToInt('a'));
54         assertEquals(11, Conversion.hexDigitToInt('B'));
55         assertEquals(11, Conversion.hexDigitToInt('b'));
56         assertEquals(12, Conversion.hexDigitToInt('C'));
57         assertEquals(12, Conversion.hexDigitToInt('c'));
58         assertEquals(13, Conversion.hexDigitToInt('D'));
59         assertEquals(13, Conversion.hexDigitToInt('d'));
60         assertEquals(14, Conversion.hexDigitToInt('E'));
61         assertEquals(14, Conversion.hexDigitToInt('e'));
62         assertEquals(15, Conversion.hexDigitToInt('F'));
63         assertEquals(15, Conversion.hexDigitToInt('f'));
64         assertThrows(IllegalArgumentException.class, () -> Conversion.hexDigitToInt('G'));
65     }
66 
67     /**
68      * Tests {@link Conversion#hexDigitMsb0ToInt(char)}.
69      */
70     @Test
testHexDigitMsb0ToInt()71     public void testHexDigitMsb0ToInt() {
72         assertEquals(0x0, Conversion.hexDigitMsb0ToInt('0'));
73         assertEquals(0x8, Conversion.hexDigitMsb0ToInt('1'));
74         assertEquals(0x4, Conversion.hexDigitMsb0ToInt('2'));
75         assertEquals(0xC, Conversion.hexDigitMsb0ToInt('3'));
76         assertEquals(0x2, Conversion.hexDigitMsb0ToInt('4'));
77         assertEquals(0xA, Conversion.hexDigitMsb0ToInt('5'));
78         assertEquals(0x6, Conversion.hexDigitMsb0ToInt('6'));
79         assertEquals(0xE, Conversion.hexDigitMsb0ToInt('7'));
80         assertEquals(0x1, Conversion.hexDigitMsb0ToInt('8'));
81         assertEquals(0x9, Conversion.hexDigitMsb0ToInt('9'));
82         assertEquals(0x5, Conversion.hexDigitMsb0ToInt('A'));
83         assertEquals(0x5, Conversion.hexDigitMsb0ToInt('a'));
84         assertEquals(0xD, Conversion.hexDigitMsb0ToInt('B'));
85         assertEquals(0xD, Conversion.hexDigitMsb0ToInt('b'));
86         assertEquals(0x3, Conversion.hexDigitMsb0ToInt('C'));
87         assertEquals(0x3, Conversion.hexDigitMsb0ToInt('c'));
88         assertEquals(0xB, Conversion.hexDigitMsb0ToInt('D'));
89         assertEquals(0xB, Conversion.hexDigitMsb0ToInt('d'));
90         assertEquals(0x7, Conversion.hexDigitMsb0ToInt('E'));
91         assertEquals(0x7, Conversion.hexDigitMsb0ToInt('e'));
92         assertEquals(0xF, Conversion.hexDigitMsb0ToInt('F'));
93         assertEquals(0xF, Conversion.hexDigitMsb0ToInt('f'));
94         assertThrows(IllegalArgumentException.class, () -> Conversion.hexDigitMsb0ToInt('G'));
95     }
96 
97     /**
98      * Tests {@link Conversion#hexDigitToBinary(char)}.
99      */
100     @Test
testHexDigitToBinary()101     public void testHexDigitToBinary() {
102         assertArrayEquals(
103             new boolean[]{false, false, false, false}, Conversion.hexDigitToBinary('0'));
104         assertArrayEquals(
105             new boolean[]{true, false, false, false}, Conversion.hexDigitToBinary('1'));
106         assertArrayEquals(
107             new boolean[]{false, true, false, false}, Conversion.hexDigitToBinary('2'));
108         assertArrayEquals(
109             new boolean[]{true, true, false, false}, Conversion.hexDigitToBinary('3'));
110         assertArrayEquals(
111             new boolean[]{false, false, true, false}, Conversion.hexDigitToBinary('4'));
112         assertArrayEquals(
113             new boolean[]{true, false, true, false}, Conversion.hexDigitToBinary('5'));
114         assertArrayEquals(
115             new boolean[]{false, true, true, false}, Conversion.hexDigitToBinary('6'));
116         assertArrayEquals(
117             new boolean[]{true, true, true, false}, Conversion.hexDigitToBinary('7'));
118         assertArrayEquals(
119             new boolean[]{false, false, false, true}, Conversion.hexDigitToBinary('8'));
120         assertArrayEquals(
121             new boolean[]{true, false, false, true}, Conversion.hexDigitToBinary('9'));
122         assertArrayEquals(
123             new boolean[]{false, true, false, true}, Conversion.hexDigitToBinary('A'));
124         assertArrayEquals(
125             new boolean[]{false, true, false, true}, Conversion.hexDigitToBinary('a'));
126         assertArrayEquals(
127             new boolean[]{true, true, false, true}, Conversion.hexDigitToBinary('B'));
128         assertArrayEquals(
129             new boolean[]{true, true, false, true}, Conversion.hexDigitToBinary('b'));
130         assertArrayEquals(
131             new boolean[]{false, false, true, true}, Conversion.hexDigitToBinary('C'));
132         assertArrayEquals(
133             new boolean[]{false, false, true, true}, Conversion.hexDigitToBinary('c'));
134         assertArrayEquals(
135             new boolean[]{true, false, true, true}, Conversion.hexDigitToBinary('D'));
136         assertArrayEquals(
137             new boolean[]{true, false, true, true}, Conversion.hexDigitToBinary('d'));
138         assertArrayEquals(
139             new boolean[]{false, true, true, true}, Conversion.hexDigitToBinary('E'));
140         assertArrayEquals(
141             new boolean[]{false, true, true, true}, Conversion.hexDigitToBinary('e'));
142         assertArrayEquals(
143             new boolean[]{true, true, true, true}, Conversion.hexDigitToBinary('F'));
144         assertArrayEquals(
145             new boolean[]{true, true, true, true}, Conversion.hexDigitToBinary('f'));
146         assertThrows(IllegalArgumentException.class, () -> Conversion.hexDigitToBinary('G'));
147     }
148 
149     /**
150      * Tests {@link Conversion#hexDigitMsb0ToBinary(char)}.
151      */
152     @Test
testHexDigitMsb0ToBinary()153     public void testHexDigitMsb0ToBinary() {
154         assertArrayEquals(
155             new boolean[]{false, false, false, false}, Conversion.hexDigitMsb0ToBinary('0'));
156         assertArrayEquals(
157             new boolean[]{false, false, false, true}, Conversion.hexDigitMsb0ToBinary('1'));
158         assertArrayEquals(
159             new boolean[]{false, false, true, false}, Conversion.hexDigitMsb0ToBinary('2'));
160         assertArrayEquals(
161             new boolean[]{false, false, true, true}, Conversion.hexDigitMsb0ToBinary('3'));
162         assertArrayEquals(
163             new boolean[]{false, true, false, false}, Conversion.hexDigitMsb0ToBinary('4'));
164         assertArrayEquals(
165             new boolean[]{false, true, false, true}, Conversion.hexDigitMsb0ToBinary('5'));
166         assertArrayEquals(
167             new boolean[]{false, true, true, false}, Conversion.hexDigitMsb0ToBinary('6'));
168         assertArrayEquals(
169             new boolean[]{false, true, true, true}, Conversion.hexDigitMsb0ToBinary('7'));
170         assertArrayEquals(
171             new boolean[]{true, false, false, false}, Conversion.hexDigitMsb0ToBinary('8'));
172         assertArrayEquals(
173             new boolean[]{true, false, false, true}, Conversion.hexDigitMsb0ToBinary('9'));
174         assertArrayEquals(
175             new boolean[]{true, false, true, false}, Conversion.hexDigitMsb0ToBinary('A'));
176         assertArrayEquals(
177             new boolean[]{true, false, true, false}, Conversion.hexDigitMsb0ToBinary('a'));
178         assertArrayEquals(
179             new boolean[]{true, false, true, true}, Conversion.hexDigitMsb0ToBinary('B'));
180         assertArrayEquals(
181             new boolean[]{true, false, true, true}, Conversion.hexDigitMsb0ToBinary('b'));
182         assertArrayEquals(
183             new boolean[]{true, true, false, false}, Conversion.hexDigitMsb0ToBinary('C'));
184         assertArrayEquals(
185             new boolean[]{true, true, false, false}, Conversion.hexDigitMsb0ToBinary('c'));
186         assertArrayEquals(
187             new boolean[]{true, true, false, true}, Conversion.hexDigitMsb0ToBinary('D'));
188         assertArrayEquals(
189             new boolean[]{true, true, false, true}, Conversion.hexDigitMsb0ToBinary('d'));
190         assertArrayEquals(
191             new boolean[]{true, true, true, false}, Conversion.hexDigitMsb0ToBinary('E'));
192         assertArrayEquals(
193             new boolean[]{true, true, true, false}, Conversion.hexDigitMsb0ToBinary('e'));
194         assertArrayEquals(
195             new boolean[]{true, true, true, true}, Conversion.hexDigitMsb0ToBinary('F'));
196         assertArrayEquals(
197             new boolean[]{true, true, true, true}, Conversion.hexDigitMsb0ToBinary('f'));
198         assertThrows(IllegalArgumentException.class, () -> Conversion.hexDigitMsb0ToBinary('G'));
199     }
200 
201     /**
202      * Tests {@link Conversion#binaryToHexDigit(boolean[])}.
203      */
204     @Test
testBinaryToHexDigit()205     public void testBinaryToHexDigit() {
206         assertEquals(
207             '0', Conversion.binaryToHexDigit(new boolean[]{false, false, false, false}));
208         assertEquals('1', Conversion.binaryToHexDigit(new boolean[]{true, false, false, false}));
209         assertEquals('2', Conversion.binaryToHexDigit(new boolean[]{false, true, false, false}));
210         assertEquals('3', Conversion.binaryToHexDigit(new boolean[]{true, true, false, false}));
211         assertEquals('4', Conversion.binaryToHexDigit(new boolean[]{false, false, true, false}));
212         assertEquals('5', Conversion.binaryToHexDigit(new boolean[]{true, false, true, false}));
213         assertEquals('6', Conversion.binaryToHexDigit(new boolean[]{false, true, true, false}));
214         assertEquals('7', Conversion.binaryToHexDigit(new boolean[]{true, true, true, false}));
215         assertEquals('8', Conversion.binaryToHexDigit(new boolean[]{false, false, false, true}));
216         assertEquals('9', Conversion.binaryToHexDigit(new boolean[]{true, false, false, true}));
217         assertEquals('a', Conversion.binaryToHexDigit(new boolean[]{false, true, false, true}));
218         assertEquals('b', Conversion.binaryToHexDigit(new boolean[]{true, true, false, true}));
219         assertEquals('c', Conversion.binaryToHexDigit(new boolean[]{false, false, true, true}));
220         assertEquals('d', Conversion.binaryToHexDigit(new boolean[]{true, false, true, true}));
221         assertEquals('e', Conversion.binaryToHexDigit(new boolean[]{false, true, true, true}));
222         assertEquals('f', Conversion.binaryToHexDigit(new boolean[]{true, true, true, true}));
223         assertEquals('1', Conversion.binaryToHexDigit(new boolean[]{true}));
224         assertEquals(
225             'f', Conversion.binaryToHexDigit(new boolean[]{true, true, true, true, true}));
226         assertThrows(IllegalArgumentException.class, () -> Conversion.binaryToHexDigit(new boolean[]{}));
227     }
228 
229     /**
230      * Tests {@link Conversion#binaryBeMsb0ToHexDigit(boolean[], int)}.
231      */
232     @Test
testBinaryToHexDigit_2args()233     public void testBinaryToHexDigit_2args() {
234         final boolean[] shortArray = {false, true, true};
235         assertEquals('6', Conversion.binaryToHexDigit(shortArray, 0));
236         assertEquals('3', Conversion.binaryToHexDigit(shortArray, 1));
237         assertEquals('1', Conversion.binaryToHexDigit(shortArray, 2));
238         final boolean[] longArray = {true, false, true, false, false, true, true};
239         assertEquals('5', Conversion.binaryToHexDigit(longArray, 0));
240         assertEquals('2', Conversion.binaryToHexDigit(longArray, 1));
241         assertEquals('9', Conversion.binaryToHexDigit(longArray, 2));
242         assertEquals('c', Conversion.binaryToHexDigit(longArray, 3));
243         assertEquals('6', Conversion.binaryToHexDigit(longArray, 4));
244         assertEquals('3', Conversion.binaryToHexDigit(longArray, 5));
245         assertEquals('1', Conversion.binaryToHexDigit(longArray, 6));
246     }
247 
248     /**
249      * Tests {@link Conversion#binaryToHexDigitMsb0_4bits(boolean[])}.
250      */
251     @Test
testBinaryToHexDigitMsb0_bits()252     public void testBinaryToHexDigitMsb0_bits() {
253         assertEquals(
254             '0',
255             Conversion.binaryToHexDigitMsb0_4bits(new boolean[]{false, false, false, false}));
256         assertEquals(
257             '1',
258             Conversion.binaryToHexDigitMsb0_4bits(new boolean[]{false, false, false, true}));
259         assertEquals(
260             '2',
261             Conversion.binaryToHexDigitMsb0_4bits(new boolean[]{false, false, true, false}));
262         assertEquals(
263             '3', Conversion.binaryToHexDigitMsb0_4bits(new boolean[]{false, false, true, true}));
264         assertEquals(
265             '4',
266             Conversion.binaryToHexDigitMsb0_4bits(new boolean[]{false, true, false, false}));
267         assertEquals(
268             '5', Conversion.binaryToHexDigitMsb0_4bits(new boolean[]{false, true, false, true}));
269         assertEquals(
270             '6', Conversion.binaryToHexDigitMsb0_4bits(new boolean[]{false, true, true, false}));
271         assertEquals(
272             '7', Conversion.binaryToHexDigitMsb0_4bits(new boolean[]{false, true, true, true}));
273         assertEquals(
274             '8',
275             Conversion.binaryToHexDigitMsb0_4bits(new boolean[]{true, false, false, false}));
276         assertEquals(
277             '9', Conversion.binaryToHexDigitMsb0_4bits(new boolean[]{true, false, false, true}));
278         assertEquals(
279             'a', Conversion.binaryToHexDigitMsb0_4bits(new boolean[]{true, false, true, false}));
280         assertEquals(
281             'b', Conversion.binaryToHexDigitMsb0_4bits(new boolean[]{true, false, true, true}));
282         assertEquals(
283             'c', Conversion.binaryToHexDigitMsb0_4bits(new boolean[]{true, true, false, false}));
284         assertEquals(
285             'd', Conversion.binaryToHexDigitMsb0_4bits(new boolean[]{true, true, false, true}));
286         assertEquals(
287             'e', Conversion.binaryToHexDigitMsb0_4bits(new boolean[]{true, true, true, false}));
288         assertEquals(
289             'f', Conversion.binaryToHexDigitMsb0_4bits(new boolean[]{true, true, true, true}));
290         assertThrows(IllegalArgumentException.class, () -> Conversion.binaryToHexDigitMsb0_4bits(new boolean[]{}));
291     }
292 
293     /**
294      * Tests {@link Conversion#binaryToHexDigitMsb0_4bits(boolean[], int)}.
295      */
296     @Test
testBinaryToHexDigitMsb0_4bits_2args()297     public void testBinaryToHexDigitMsb0_4bits_2args() {
298         // boolean[] shortArray = new boolean[]{true, true, false};
299         // assertEquals('6', Conversion.BinaryToHexDigitMsb0(shortArray, 0));
300         // assertEquals('3', Conversion.BinaryToHexDigitMsb0(shortArray, 1));
301         // assertEquals('1', Conversion.BinaryToHexDigitMsb0(shortArray, 2));
302         final boolean[] shortArray = {true, true, false, true};
303         assertEquals('d', Conversion.binaryToHexDigitMsb0_4bits(shortArray, 0));
304         final boolean[] longArray = {true, false, true, false, false, true, true};
305         assertEquals('a', Conversion.binaryToHexDigitMsb0_4bits(longArray, 0));
306         assertEquals('4', Conversion.binaryToHexDigitMsb0_4bits(longArray, 1));
307         assertEquals('9', Conversion.binaryToHexDigitMsb0_4bits(longArray, 2));
308         assertEquals('3', Conversion.binaryToHexDigitMsb0_4bits(longArray, 3));
309         // assertEquals('6', Conversion.BinaryToHexDigitMsb0(longArray, 4));
310         // assertEquals('3', Conversion.BinaryToHexDigitMsb0(longArray, 5));
311         // assertEquals('1', Conversion.BinaryToHexDigitMsb0(longArray, 6));
312         final boolean[] maxLengthArray = {
313             true, false, true, false, false, true, true, true};
314         assertEquals('a', Conversion.binaryToHexDigitMsb0_4bits(maxLengthArray, 0));
315         assertEquals('4', Conversion.binaryToHexDigitMsb0_4bits(maxLengthArray, 1));
316         assertEquals('9', Conversion.binaryToHexDigitMsb0_4bits(maxLengthArray, 2));
317         assertEquals('3', Conversion.binaryToHexDigitMsb0_4bits(maxLengthArray, 3));
318         assertEquals('7', Conversion.binaryToHexDigitMsb0_4bits(maxLengthArray, 4));
319         // assertEquals('7', Conversion.BinaryToHexDigitMsb0(longArray, 5));
320         // assertEquals('3', Conversion.BinaryToHexDigitMsb0(longArray, 6));
321         // assertEquals('1', Conversion.BinaryToHexDigitMsb0(longArray, 7));
322         final boolean[] javaDocCheck = {
323             true, false, false, true, true, false, true, false};
324         assertEquals('d', Conversion.binaryToHexDigitMsb0_4bits(javaDocCheck, 3));
325 
326     }
327 
328     /**
329      * Tests {@link Conversion#binaryToHexDigit(boolean[])}.
330      */
331     @Test
testBinaryBeMsb0ToHexDigit()332     public void testBinaryBeMsb0ToHexDigit() {
333         assertEquals(
334             '0', Conversion.binaryBeMsb0ToHexDigit(new boolean[]{false, false, false, false}));
335         assertEquals(
336             '1', Conversion.binaryBeMsb0ToHexDigit(new boolean[]{false, false, false, true}));
337         assertEquals(
338             '2', Conversion.binaryBeMsb0ToHexDigit(new boolean[]{false, false, true, false}));
339         assertEquals(
340             '3', Conversion.binaryBeMsb0ToHexDigit(new boolean[]{false, false, true, true}));
341         assertEquals(
342             '4', Conversion.binaryBeMsb0ToHexDigit(new boolean[]{false, true, false, false}));
343         assertEquals(
344             '5', Conversion.binaryBeMsb0ToHexDigit(new boolean[]{false, true, false, true}));
345         assertEquals(
346             '6', Conversion.binaryBeMsb0ToHexDigit(new boolean[]{false, true, true, false}));
347         assertEquals(
348             '7', Conversion.binaryBeMsb0ToHexDigit(new boolean[]{false, true, true, true}));
349         assertEquals(
350             '8', Conversion.binaryBeMsb0ToHexDigit(new boolean[]{true, false, false, false}));
351         assertEquals(
352             '9', Conversion.binaryBeMsb0ToHexDigit(new boolean[]{true, false, false, true}));
353         assertEquals(
354             'a', Conversion.binaryBeMsb0ToHexDigit(new boolean[]{true, false, true, false}));
355         assertEquals(
356             'b', Conversion.binaryBeMsb0ToHexDigit(new boolean[]{true, false, true, true}));
357         assertEquals(
358             'c', Conversion.binaryBeMsb0ToHexDigit(new boolean[]{true, true, false, false}));
359         assertEquals(
360             'd', Conversion.binaryBeMsb0ToHexDigit(new boolean[]{true, true, false, true}));
361         assertEquals(
362             'e', Conversion.binaryBeMsb0ToHexDigit(new boolean[]{true, true, true, false}));
363         assertEquals(
364             'f', Conversion.binaryBeMsb0ToHexDigit(new boolean[]{true, true, true, true}));
365         assertEquals(
366             '4',
367             Conversion.binaryBeMsb0ToHexDigit(new boolean[]{
368                 true, false, false, false, false, false, false, false, false, false, false,
369                 false, false, true, false, false}));
370         assertThrows(IllegalArgumentException.class, () -> Conversion.binaryBeMsb0ToHexDigit(new boolean[]{}));
371     }
372 
373     /**
374      * Tests {@link Conversion#binaryToHexDigit(boolean[], int)}.
375      */
376     @Test
testBinaryBeMsb0ToHexDigit_2args()377     public void testBinaryBeMsb0ToHexDigit_2args() {
378         assertEquals(
379             '5',
380             Conversion.binaryBeMsb0ToHexDigit(new boolean[]{
381                 true, false, false, false, false, false, false, false, false, false, false,
382                 true, false, true, false, false}, 2));
383 
384         final boolean[] shortArray = {true, true, false};
385         assertEquals('6', Conversion.binaryBeMsb0ToHexDigit(shortArray, 0));
386         assertEquals('3', Conversion.binaryBeMsb0ToHexDigit(shortArray, 1));
387         assertEquals('1', Conversion.binaryBeMsb0ToHexDigit(shortArray, 2));
388         final boolean[] shortArray2 = {true, true, true, false, false, true, false, true};
389         assertEquals('5', Conversion.binaryBeMsb0ToHexDigit(shortArray2, 0));
390         assertEquals('2', Conversion.binaryBeMsb0ToHexDigit(shortArray2, 1));
391         assertEquals('9', Conversion.binaryBeMsb0ToHexDigit(shortArray2, 2));
392         assertEquals('c', Conversion.binaryBeMsb0ToHexDigit(shortArray2, 3));
393         assertEquals('e', Conversion.binaryBeMsb0ToHexDigit(shortArray2, 4));
394         assertEquals('7', Conversion.binaryBeMsb0ToHexDigit(shortArray2, 5));
395         assertEquals('3', Conversion.binaryBeMsb0ToHexDigit(shortArray2, 6));
396         assertEquals('1', Conversion.binaryBeMsb0ToHexDigit(shortArray2, 7));
397         final boolean[] multiBytesArray = {
398             true, true, false, false, true, false, true, false, true, true, true, false, false,
399             true, false, true};
400         assertEquals('5', Conversion.binaryBeMsb0ToHexDigit(multiBytesArray, 0));
401         assertEquals('2', Conversion.binaryBeMsb0ToHexDigit(multiBytesArray, 1));
402         assertEquals('9', Conversion.binaryBeMsb0ToHexDigit(multiBytesArray, 2));
403         assertEquals('c', Conversion.binaryBeMsb0ToHexDigit(multiBytesArray, 3));
404         assertEquals('e', Conversion.binaryBeMsb0ToHexDigit(multiBytesArray, 4));
405         assertEquals('7', Conversion.binaryBeMsb0ToHexDigit(multiBytesArray, 5));
406         assertEquals('b', Conversion.binaryBeMsb0ToHexDigit(multiBytesArray, 6));
407         assertEquals('5', Conversion.binaryBeMsb0ToHexDigit(multiBytesArray, 7));
408 
409         assertEquals('a', Conversion.binaryBeMsb0ToHexDigit(multiBytesArray, 8));
410         assertEquals('5', Conversion.binaryBeMsb0ToHexDigit(multiBytesArray, 9));
411         assertEquals('2', Conversion.binaryBeMsb0ToHexDigit(multiBytesArray, 10));
412         assertEquals('9', Conversion.binaryBeMsb0ToHexDigit(multiBytesArray, 11));
413         assertEquals('c', Conversion.binaryBeMsb0ToHexDigit(multiBytesArray, 12));
414         assertEquals('6', Conversion.binaryBeMsb0ToHexDigit(multiBytesArray, 13));
415         assertEquals('3', Conversion.binaryBeMsb0ToHexDigit(multiBytesArray, 14));
416         assertEquals('1', Conversion.binaryBeMsb0ToHexDigit(multiBytesArray, 15));
417 
418     }
419 
420     @Test
testBinaryToHexDigitReverse()421     public void testBinaryToHexDigitReverse() {
422         final SplittableRandom rng = new SplittableRandom();
423         final boolean[] x = new boolean[8];
424         for (int i = 0; i < 100; i++) {
425             Conversion.longToBinary(rng.nextLong(), 0, x, 0, 8);
426             for (int j = 1; j <= 8; j++) {
427                 final boolean[] a = Arrays.copyOf(x, j);
428                 final boolean[] b = a.clone();
429                 ArrayUtils.reverse(b);
430                 for (int k = 0; k < j; k++) {
431                     assertEquals(Conversion.binaryToHexDigit(a, k),
432                                  Conversion.binaryBeMsb0ToHexDigit(b, k));
433                 }
434             }
435         }
436     }
437 
438     @ParameterizedTest
439     @ValueSource(ints = {-1, 8, 99})
binaryBeMsb0ToHexDigitPosOutsideArray(final int index)440     public void binaryBeMsb0ToHexDigitPosOutsideArray(final int index) {
441         assertThrows(IndexOutOfBoundsException.class,
442             () -> Conversion.binaryBeMsb0ToHexDigit(new boolean[8], index));
443     }
444 
445     /**
446      * Tests {@link Conversion#intToHexDigit(int)}.
447      */
448     @Test
testIntToHexDigit()449     public void testIntToHexDigit() {
450         assertEquals('0', Conversion.intToHexDigit(0));
451         assertEquals('1', Conversion.intToHexDigit(1));
452         assertEquals('2', Conversion.intToHexDigit(2));
453         assertEquals('3', Conversion.intToHexDigit(3));
454         assertEquals('4', Conversion.intToHexDigit(4));
455         assertEquals('5', Conversion.intToHexDigit(5));
456         assertEquals('6', Conversion.intToHexDigit(6));
457         assertEquals('7', Conversion.intToHexDigit(7));
458         assertEquals('8', Conversion.intToHexDigit(8));
459         assertEquals('9', Conversion.intToHexDigit(9));
460         assertEquals('a', Conversion.intToHexDigit(10));
461         assertEquals('b', Conversion.intToHexDigit(11));
462         assertEquals('c', Conversion.intToHexDigit(12));
463         assertEquals('d', Conversion.intToHexDigit(13));
464         assertEquals('e', Conversion.intToHexDigit(14));
465         assertEquals('f', Conversion.intToHexDigit(15));
466         assertThrows(IllegalArgumentException.class, () -> Conversion.intToHexDigit(16));
467     }
468 
469     /**
470      * Tests {@link Conversion#intToHexDigitMsb0(int)}.
471      */
472     @Test
testIntToHexDigitMsb0()473     public void testIntToHexDigitMsb0() {
474         assertEquals('0', Conversion.intToHexDigitMsb0(0));
475         assertEquals('8', Conversion.intToHexDigitMsb0(1));
476         assertEquals('4', Conversion.intToHexDigitMsb0(2));
477         assertEquals('c', Conversion.intToHexDigitMsb0(3));
478         assertEquals('2', Conversion.intToHexDigitMsb0(4));
479         assertEquals('a', Conversion.intToHexDigitMsb0(5));
480         assertEquals('6', Conversion.intToHexDigitMsb0(6));
481         assertEquals('e', Conversion.intToHexDigitMsb0(7));
482         assertEquals('1', Conversion.intToHexDigitMsb0(8));
483         assertEquals('9', Conversion.intToHexDigitMsb0(9));
484         assertEquals('5', Conversion.intToHexDigitMsb0(10));
485         assertEquals('d', Conversion.intToHexDigitMsb0(11));
486         assertEquals('3', Conversion.intToHexDigitMsb0(12));
487         assertEquals('b', Conversion.intToHexDigitMsb0(13));
488         assertEquals('7', Conversion.intToHexDigitMsb0(14));
489         assertEquals('f', Conversion.intToHexDigitMsb0(15));
490         assertThrows(IllegalArgumentException.class, () -> Conversion.intToHexDigitMsb0(16));
491     }
492 
dbgPrint(final boolean[] src)493     static String dbgPrint(final boolean[] src) {
494         final StringBuilder sb = new StringBuilder();
495         for (final boolean e : src) {
496             if (e) {
497                 sb.append("1, ");
498             } else {
499                 sb.append("0, ");
500             }
501         }
502         final String out = sb.toString();
503         return out.substring(0, out.length() - 1);
504     }
505 
506     /**
507      * Tests {@link Conversion#intArrayToLong(int[], int, long, int, int)}.
508      */
509     @Test
testIntArrayToLong()510     public void testIntArrayToLong() {
511         final int[] src = {0xCDF1F0C1, 0x0F123456, 0x78000000};
512         assertEquals(0x0000000000000000L, Conversion.intArrayToLong(src, 0, 0L, 0, 0));
513         assertEquals(0x0000000000000000L, Conversion.intArrayToLong(src, 1, 0L, 0, 0));
514         assertEquals(0x00000000CDF1F0C1L, Conversion.intArrayToLong(src, 0, 0L, 0, 1));
515         assertEquals(0x0F123456CDF1F0C1L, Conversion.intArrayToLong(src, 0, 0L, 0, 2));
516         assertEquals(0x000000000F123456L, Conversion.intArrayToLong(src, 1, 0L, 0, 1));
517         assertEquals(
518             0x123456789ABCDEF0L, Conversion.intArrayToLong(src, 0, 0x123456789ABCDEF0L, 0, 0));
519         assertEquals(
520             0x1234567878000000L, Conversion.intArrayToLong(src, 2, 0x123456789ABCDEF0L, 0, 1));
521         // assertEquals(0x0F12345678000000L, Conversion.intsToLong(src, 1, 0x123456789ABCDEF0L, 32, 2));
522     }
523 
524     /**
525      * Tests {@link Conversion#shortArrayToLong(short[], int, long, int, int)}.
526      */
527     @Test
testShortArrayToLong()528     public void testShortArrayToLong() {
529         final short[] src = {
530             (short) 0xCDF1, (short) 0xF0C1, (short) 0x0F12, (short) 0x3456, (short) 0x7800};
531         assertEquals(0x0000000000000000L, Conversion.shortArrayToLong(src, 0, 0L, 0, 0));
532         assertEquals(0x000000000000CDF1L, Conversion.shortArrayToLong(src, 0, 0L, 0, 1));
533         assertEquals(0x00000000F0C1CDF1L, Conversion.shortArrayToLong(src, 0, 0L, 0, 2));
534         assertEquals(0x780034560F12F0C1L, Conversion.shortArrayToLong(src, 1, 0L, 0, 4));
535         assertEquals(
536             0x123456789ABCDEF0L, Conversion.shortArrayToLong(src, 0, 0x123456789ABCDEF0L, 0, 0));
537         assertEquals(
538             0x123456CDF1BCDEF0L,
539             Conversion.shortArrayToLong(src, 0, 0x123456789ABCDEF0L, 24, 1));
540         assertEquals(
541             0x123478003456DEF0L,
542             Conversion.shortArrayToLong(src, 3, 0x123456789ABCDEF0L, 16, 2));
543     }
544 
545     /**
546      * Tests {@link Conversion#byteArrayToLong(byte[], int, long, int, int)}.
547      */
548     @Test
testByteArrayToLong()549     public void testByteArrayToLong() {
550         final byte[] src = {
551             (byte) 0xCD, (byte) 0xF1, (byte) 0xF0, (byte) 0xC1, (byte) 0x0F, (byte) 0x12, (byte) 0x34,
552             (byte) 0x56, (byte) 0x78};
553         assertEquals(0x0000000000000000L, Conversion.byteArrayToLong(src, 0, 0L, 0, 0));
554         assertEquals(0x00000000000000CDL, Conversion.byteArrayToLong(src, 0, 0L, 0, 1));
555         assertEquals(0x00000000C1F0F1CDL, Conversion.byteArrayToLong(src, 0, 0L, 0, 4));
556         assertEquals(0x000000000FC1F0F1L, Conversion.byteArrayToLong(src, 1, 0L, 0, 4));
557         assertEquals(
558             0x123456789ABCDEF0L, Conversion.byteArrayToLong(src, 0, 0x123456789ABCDEF0L, 0, 0));
559         assertEquals(
560             0x12345678CDBCDEF0L, Conversion.byteArrayToLong(src, 0, 0x123456789ABCDEF0L, 24, 1));
561         assertEquals(
562             0x123456789A7856F0L, Conversion.byteArrayToLong(src, 7, 0x123456789ABCDEF0L, 8, 2));
563     }
564 
565     /**
566      * Tests {@link Conversion#shortArrayToInt(short[], int, int, int, int)}.
567      */
568     @Test
testShortArrayToInt()569     public void testShortArrayToInt() {
570         final short[] src = {
571             (short) 0xCDF1, (short) 0xF0C1, (short) 0x0F12, (short) 0x3456, (short) 0x7800};
572         assertEquals(0x00000000, Conversion.shortArrayToInt(src, 0, 0, 0, 0));
573         assertEquals(0x0000CDF1, Conversion.shortArrayToInt(src, 0, 0, 0, 1));
574         assertEquals(0xF0C1CDF1, Conversion.shortArrayToInt(src, 0, 0, 0, 2));
575         assertEquals(0x0F12F0C1, Conversion.shortArrayToInt(src, 1, 0, 0, 2));
576         assertEquals(0x12345678, Conversion.shortArrayToInt(src, 0, 0x12345678, 0, 0));
577         assertEquals(0xCDF15678, Conversion.shortArrayToInt(src, 0, 0x12345678, 16, 1));
578         // assertEquals(0x34567800, Conversion.ShortArrayToInt(src, 3, 0x12345678, 16, 2));
579     }
580 
581     /**
582      * Tests {@link Conversion#byteArrayToInt(byte[], int, int, int, int)}.
583      */
584     @Test
testByteArrayToInt()585     public void testByteArrayToInt() {
586         final byte[] src = {
587             (byte) 0xCD, (byte) 0xF1, (byte) 0xF0, (byte) 0xC1, (byte) 0x0F, (byte) 0x12, (byte) 0x34,
588             (byte) 0x56, (byte) 0x78};
589         assertEquals(0x00000000, Conversion.byteArrayToInt(src, 0, 0, 0, 0));
590         assertEquals(0x000000CD, Conversion.byteArrayToInt(src, 0, 0, 0, 1));
591         assertEquals(0xC1F0F1CD, Conversion.byteArrayToInt(src, 0, 0, 0, 4));
592         assertEquals(0x0FC1F0F1, Conversion.byteArrayToInt(src, 1, 0, 0, 4));
593         assertEquals(0x12345678, Conversion.byteArrayToInt(src, 0, 0x12345678, 0, 0));
594         assertEquals(0xCD345678, Conversion.byteArrayToInt(src, 0, 0x12345678, 24, 1));
595         // assertEquals(0x56341278, Conversion.ByteArrayToInt(src, 5, 0x01234567, 8, 4));
596     }
597 
598     /**
599      * Tests {@link Conversion#byteArrayToShort(byte[], int, short, int, int)}.
600      */
601     @Test
testByteArrayToShort()602     public void testByteArrayToShort() {
603         final byte[] src = {
604             (byte) 0xCD, (byte) 0xF1, (byte) 0xF0, (byte) 0xC1, (byte) 0x0F, (byte) 0x12, (byte) 0x34,
605             (byte) 0x56, (byte) 0x78};
606         assertEquals((short) 0x0000, Conversion.byteArrayToShort(src, 0, (short) 0, 0, 0));
607         assertEquals((short) 0x00CD, Conversion.byteArrayToShort(src, 0, (short) 0, 0, 1));
608         assertEquals((short) 0xF1CD, Conversion.byteArrayToShort(src, 0, (short) 0, 0, 2));
609         assertEquals((short) 0xF0F1, Conversion.byteArrayToShort(src, 1, (short) 0, 0, 2));
610         assertEquals((short) 0x1234, Conversion.byteArrayToShort(src, 0, (short) 0x1234, 0, 0));
611         assertEquals((short) 0xCD34, Conversion.byteArrayToShort(src, 0, (short) 0x1234, 8, 1));
612         // assertEquals((short) 0x5678, Conversion.ByteArrayToShort(src, 7, (short) 0x0123, 8,
613         // 2));
614     }
615 
616     /**
617      * Tests {@link Conversion#hexToLong(String, int, long, int, int)}.
618      */
619     @Test
testHexToLong()620     public void testHexToLong() {
621         final String src = "CDF1F0C10F12345678";
622         assertEquals(0x0000000000000000L, Conversion.hexToLong(src, 0, 0L, 0, 0));
623         assertEquals(0x000000000000000CL, Conversion.hexToLong(src, 0, 0L, 0, 1));
624         assertEquals(0x000000001C0F1FDCL, Conversion.hexToLong(src, 0, 0L, 0, 8));
625         assertEquals(0x0000000001C0F1FDL, Conversion.hexToLong(src, 1, 0L, 0, 8));
626         assertEquals(
627             0x123456798ABCDEF0L, Conversion.hexToLong(src, 0, 0x123456798ABCDEF0L, 0, 0));
628         assertEquals(
629             0x1234567876BCDEF0L, Conversion.hexToLong(src, 15, 0x123456798ABCDEF0L, 24, 3));
630     }
631 
632     /**
633      * Tests {@link Conversion#hexToInt(String, int, int, int, int)}.
634      */
635     @Test
testHexToInt()636     public void testHexToInt() {
637         final String src = "CDF1F0C10F12345678";
638         assertEquals(0x00000000, Conversion.hexToInt(src, 0, 0, 0, 0));
639         assertEquals(0x0000000C, Conversion.hexToInt(src, 0, 0, 0, 1));
640         assertEquals(0x1C0F1FDC, Conversion.hexToInt(src, 0, 0, 0, 8));
641         assertEquals(0x01C0F1FD, Conversion.hexToInt(src, 1, 0, 0, 8));
642         assertEquals(0x12345679, Conversion.hexToInt(src, 0, 0x12345679, 0, 0));
643         assertEquals(0x87645679, Conversion.hexToInt(src, 15, 0x12345679, 20, 3));
644     }
645 
646     /**
647      * Tests {@link Conversion#hexToShort(String, int, short, int, int)}.
648      */
649     @Test
testHexToShort()650     public void testHexToShort() {
651         final String src = "CDF1F0C10F12345678";
652         assertEquals((short) 0x0000, Conversion.hexToShort(src, 0, (short) 0, 0, 0));
653         assertEquals((short) 0x000C, Conversion.hexToShort(src, 0, (short) 0, 0, 1));
654         assertEquals((short) 0x1FDC, Conversion.hexToShort(src, 0, (short) 0, 0, 4));
655         assertEquals((short) 0xF1FD, Conversion.hexToShort(src, 1, (short) 0, 0, 4));
656         assertEquals((short) 0x1234, Conversion.hexToShort(src, 0, (short) 0x1234, 0, 0));
657         assertEquals((short) 0x8764, Conversion.hexToShort(src, 15, (short) 0x1234, 4, 3));
658     }
659 
660     /**
661      * Tests {@link Conversion#hexToByte(String, int, byte, int, int)}.
662      */
663     @Test
testHexToByte()664     public void testHexToByte() {
665         final String src = "CDF1F0C10F12345678";
666         assertEquals((byte) 0x00, Conversion.hexToByte(src, 0, (byte) 0, 0, 0));
667         assertEquals((byte) 0x0C, Conversion.hexToByte(src, 0, (byte) 0, 0, 1));
668         assertEquals((byte) 0xDC, Conversion.hexToByte(src, 0, (byte) 0, 0, 2));
669         assertEquals((byte) 0xFD, Conversion.hexToByte(src, 1, (byte) 0, 0, 2));
670         assertEquals((byte) 0x34, Conversion.hexToByte(src, 0, (byte) 0x34, 0, 0));
671         assertEquals((byte) 0x84, Conversion.hexToByte(src, 17, (byte) 0x34, 4, 1));
672     }
673 
674     /**
675      * Tests {@link Conversion#binaryToLong(boolean[], int, long, int, int)}.
676      */
677     @Test
testBinaryToLong()678     public void testBinaryToLong() {
679         final boolean[] src = {
680             false, false, true, true, true, false, true, true, true, true, true, true, true,
681             false, false, false, true, true, true, true, false, false, false, false, false,
682             false, true, true, true, false, false, false, false, false, false, false, true,
683             true, true, true, true, false, false, false, false, true, false, false, true, true,
684             false, false, false, false, true, false, true, false, true, false, false, true,
685             true, false, true, true, true, false, false, false, false, true};
686         // conversion of "CDF1F0C10F12345678" by HexToBinary
687         assertEquals(0x0000000000000000L, Conversion.binaryToLong(src, 0, 0L, 0, 0));
688         assertEquals(0x000000000000000CL, Conversion.binaryToLong(src, 0, 0L, 0, 1 * 4));
689         assertEquals(0x000000001C0F1FDCL, Conversion.binaryToLong(src, 0, 0L, 0, 8 * 4));
690         assertEquals(0x0000000001C0F1FDL, Conversion.binaryToLong(src, 1 * 4, 0L, 0, 8 * 4));
691         assertEquals(
692             0x123456798ABCDEF0L, Conversion.binaryToLong(src, 0, 0x123456798ABCDEF0L, 0, 0));
693         assertEquals(
694             0x1234567876BCDEF0L,
695             Conversion.binaryToLong(src, 15 * 4, 0x123456798ABCDEF0L, 24, 3 * 4));
696     }
697 
698     /**
699      * Tests {@link Conversion#binaryToInt(boolean[], int, int, int, int)}.
700      */
701     @Test
testBinaryToInt()702     public void testBinaryToInt() {
703         final boolean[] src = {
704             false, false, true, true, true, false, true, true, true, true, true, true, true,
705             false, false, false, true, true, true, true, false, false, false, false, false,
706             false, true, true, true, false, false, false, false, false, false, false, true,
707             true, true, true, true, false, false, false, false, true, false, false, true, true,
708             false, false, false, false, true, false, true, false, true, false, false, true,
709             true, false, true, true, true, false, false, false, false, true};
710         // conversion of "CDF1F0C10F12345678" by HexToBinary
711         assertEquals(0x00000000, Conversion.binaryToInt(src, 0 * 4, 0, 0, 0 * 4));
712         assertEquals(0x0000000C, Conversion.binaryToInt(src, 0 * 4, 0, 0, 1 * 4));
713         assertEquals(0x1C0F1FDC, Conversion.binaryToInt(src, 0 * 4, 0, 0, 8 * 4));
714         assertEquals(0x01C0F1FD, Conversion.binaryToInt(src, 1 * 4, 0, 0, 8 * 4));
715         assertEquals(0x12345679, Conversion.binaryToInt(src, 0 * 4, 0x12345679, 0, 0 * 4));
716         assertEquals(0x87645679, Conversion.binaryToInt(src, 15 * 4, 0x12345679, 20, 3 * 4));
717     }
718 
719     /**
720      * Tests {@link Conversion#binaryToShort(boolean[], int, short, int, int)}.
721      */
722     @Test
testBinaryToShort()723     public void testBinaryToShort() {
724         final boolean[] src = {
725             false, false, true, true, true, false, true, true, true, true, true, true, true,
726             false, false, false, true, true, true, true, false, false, false, false, false,
727             false, true, true, true, false, false, false, false, false, false, false, true,
728             true, true, true, true, false, false, false, false, true, false, false, true, true,
729             false, false, false, false, true, false, true, false, true, false, false, true,
730             true, false, true, true, true, false, false, false, false, true};
731         // conversion of "CDF1F0C10F12345678" by HexToBinary
732         assertEquals((short) 0x0000, Conversion.binaryToShort(src, 0 * 4, (short) 0, 0, 0 * 4));
733         assertEquals((short) 0x000C, Conversion.binaryToShort(src, 0 * 4, (short) 0, 0, 1 * 4));
734         assertEquals((short) 0x1FDC, Conversion.binaryToShort(src, 0 * 4, (short) 0, 0, 4 * 4));
735         assertEquals((short) 0xF1FD, Conversion.binaryToShort(src, 1 * 4, (short) 0, 0, 4 * 4));
736         assertEquals(
737             (short) 0x1234, Conversion.binaryToShort(src, 0 * 4, (short) 0x1234, 0, 0 * 4));
738         assertEquals(
739             (short) 0x8764, Conversion.binaryToShort(src, 15 * 4, (short) 0x1234, 4, 3 * 4));
740     }
741 
742     /**
743      * Tests {@link Conversion#binaryToByte(boolean[], int, byte, int, int)}.
744      */
745     @Test
testBinaryToByte()746     public void testBinaryToByte() {
747         final boolean[] src = {
748             false, false, true, true, true, false, true, true, true, true, true, true, true,
749             false, false, false, true, true, true, true, false, false, false, false, false,
750             false, true, true, true, false, false, false, false, false, false, false, true,
751             true, true, true, true, false, false, false, false, true, false, false, true, true,
752             false, false, false, false, true, false, true, false, true, false, false, true,
753             true, false, true, true, true, false, false, false, false, true};
754         // conversion of "CDF1F0C10F12345678" by HexToBinary
755         assertEquals((byte) 0x00, Conversion.binaryToByte(src, 0 * 4, (byte) 0, 0, 0 * 4));
756         assertEquals((byte) 0x0C, Conversion.binaryToByte(src, 0 * 4, (byte) 0, 0, 1 * 4));
757         assertEquals((byte) 0xDC, Conversion.binaryToByte(src, 0 * 4, (byte) 0, 0, 2 * 4));
758         assertEquals((byte) 0xFD, Conversion.binaryToByte(src, 1 * 4, (byte) 0, 0, 2 * 4));
759         assertEquals((byte) 0x34, Conversion.binaryToByte(src, 0 * 4, (byte) 0x34, 0, 0 * 4));
760         assertEquals((byte) 0x84, Conversion.binaryToByte(src, 17 * 4, (byte) 0x34, 4, 1 * 4));
761     }
762 
763     /**
764      * Tests {@link Conversion#longToIntArray(long, int, int[], int, int)}.
765      */
766     @Test
testLongToIntArray()767     public void testLongToIntArray() {
768         assertArrayEquals(
769             new int[]{}, Conversion.longToIntArray(0x0000000000000000L, 0, new int[]{}, 0, 0));
770         assertArrayEquals(
771             new int[]{}, Conversion.longToIntArray(0x0000000000000000L, 100, new int[]{}, 0, 0));
772         assertArrayEquals(
773             new int[]{}, Conversion.longToIntArray(0x0000000000000000L, 0, new int[]{}, 100, 0));
774         assertArrayEquals(
775             new int[]{0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF},
776             Conversion.longToIntArray(0x1234567890ABCDEFL, 0, new int[]{-1, -1, -1, -1}, 0, 0));
777         assertArrayEquals(
778             new int[]{0x90ABCDEF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF},
779             Conversion.longToIntArray(0x1234567890ABCDEFL, 0, new int[]{-1, -1, -1, -1}, 0, 1));
780         assertArrayEquals(
781             new int[]{0x90ABCDEF, 0x12345678, 0xFFFFFFFF, 0xFFFFFFFF},
782             Conversion.longToIntArray(0x1234567890ABCDEFL, 0, new int[]{-1, -1, -1, -1}, 0, 2));
783         // assertArrayEquals(new
784         // int[]{0x90ABCDEF, 0x12345678, 0x90ABCDEF, 0x12345678}, Conversion.longToIntArray(0x1234567890ABCDEFL,
785         // 0, new int[]{-1, -1, -1, -1}, 0, 4));//rejected by assertion
786         // assertArrayEquals(new
787         // int[]{0xFFFFFFFF, 0x90ABCDEF, 0x12345678, 0x90ABCDEF}, Conversion.longToIntArray(0x1234567890ABCDEFL,
788         // 0, new int[]{-1, -1, -1, -1}, 1, 3));
789         assertArrayEquals(
790             new int[]{0xFFFFFFFF, 0xFFFFFFFF, 0x90ABCDEF, 0x12345678},
791             Conversion.longToIntArray(0x1234567890ABCDEFL, 0, new int[]{-1, -1, -1, -1}, 2, 2));
792         assertArrayEquals(
793             new int[]{0xFFFFFFFF, 0xFFFFFFFF, 0x90ABCDEF, 0xFFFFFFFF},
794             Conversion.longToIntArray(0x1234567890ABCDEFL, 0, new int[]{-1, -1, -1, -1}, 2, 1));
795         assertArrayEquals(
796             new int[]{0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x90ABCDEF},
797             Conversion.longToIntArray(0x1234567890ABCDEFL, 0, new int[]{-1, -1, -1, -1}, 3, 1));
798         assertArrayEquals(
799             new int[]{0xFFFFFFFF, 0xFFFFFFFF, 0x4855E6F7, 0xFFFFFFFF},
800             Conversion.longToIntArray(0x1234567890ABCDEFL, 1, new int[]{-1, -1, -1, -1}, 2, 1));
801         assertArrayEquals(
802             new int[]{0xFFFFFFFF, 0xFFFFFFFF, 0x242AF37B, 0xFFFFFFFF},
803             Conversion.longToIntArray(0x1234567890ABCDEFL, 2, new int[]{-1, -1, -1, -1}, 2, 1));
804         assertArrayEquals(
805             new int[]{0xFFFFFFFF, 0xFFFFFFFF, 0x121579BD, 0xFFFFFFFF},
806             Conversion.longToIntArray(0x1234567890ABCDEFL, 3, new int[]{-1, -1, -1, -1}, 2, 1));
807         assertArrayEquals(
808             new int[]{0xFFFFFFFF, 0xFFFFFFFF, 0x890ABCDE, 0xFFFFFFFF},
809             Conversion.longToIntArray(0x1234567890ABCDEFL, 4, new int[]{-1, -1, -1, -1}, 2, 1));
810         // assertArrayEquals(new
811         // int[]{0x4855E6F7, 0x091A2B3C, 0x4855E6F7, 0x091A2B3C}, Conversion.longToIntArray(0x1234567890ABCDEFL,
812         // 1, new int[]{-1, -1, -1, -1}, 0, 4));//rejected by assertion
813         assertArrayEquals(
814             new int[]{0x091A2B3C},
815             Conversion.longToIntArray(0x1234567890ABCDEFL, 33, new int[]{0}, 0, 1));
816     }
817 
818     /**
819      * Tests {@link Conversion#longToShortArray(long, int, short[], int, int)}.
820      */
821     @Test
testLongToShortArray()822     public void testLongToShortArray() {
823         assertArrayEquals(
824             new short[]{},
825             Conversion.longToShortArray(0x0000000000000000L, 0, new short[]{}, 0, 0));
826         assertArrayEquals(
827             new short[]{},
828             Conversion.longToShortArray(0x0000000000000000L, 100, new short[]{}, 0, 0));
829         assertArrayEquals(
830             new short[]{},
831             Conversion.longToShortArray(0x0000000000000000L, 0, new short[]{}, 100, 0));
832         assertArrayEquals(
833             new short[]{(short) 0xFFFF, (short) 0xFFFF, (short) 0xFFFF, (short) 0xFFFF},
834             Conversion.longToShortArray(
835                 0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 0, 0));
836         assertArrayEquals(
837             new short[]{(short) 0xCDEF, (short) 0xFFFF, (short) 0xFFFF, (short) 0xFFFF},
838             Conversion.longToShortArray(
839                 0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 0, 1));
840         assertArrayEquals(
841             new short[]{(short) 0xCDEF, (short) 0x90AB, (short) 0xFFFF, (short) 0xFFFF},
842             Conversion.longToShortArray(
843                 0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 0, 2));
844         assertArrayEquals(
845             new short[]{(short) 0xCDEF, (short) 0x90AB, (short) 0x5678, (short) 0xFFFF},
846             Conversion.longToShortArray(
847                 0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 0, 3));
848         assertArrayEquals(
849             new short[]{(short) 0xCDEF, (short) 0x90AB, (short) 0x5678, (short) 0x1234},
850             Conversion.longToShortArray(
851                 0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 0, 4));
852         assertArrayEquals(
853             new short[]{(short) 0xFFFF, (short) 0xCDEF, (short) 0x90AB, (short) 0x5678},
854             Conversion.longToShortArray(
855                 0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 1, 3));
856         assertArrayEquals(
857             new short[]{(short) 0xFFFF, (short) 0xFFFF, (short) 0xCDEF, (short) 0x90AB},
858             Conversion.longToShortArray(
859                 0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 2, 2));
860         assertArrayEquals(
861             new short[]{(short) 0xFFFF, (short) 0xFFFF, (short) 0xCDEF, (short) 0xFFFF},
862             Conversion.longToShortArray(
863                 0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 2, 1));
864         assertArrayEquals(
865             new short[]{(short) 0xFFFF, (short) 0xFFFF, (short) 0xFFFF, (short) 0xCDEF},
866             Conversion.longToShortArray(
867                 0x1234567890ABCDEFL, 0, new short[]{-1, -1, -1, -1}, 3, 1));
868         assertArrayEquals(
869             new short[]{(short) 0xFFFF, (short) 0xFFFF, (short) 0xE6F7, (short) 0xFFFF},
870             Conversion.longToShortArray(
871                 0x1234567890ABCDEFL, 1, new short[]{-1, -1, -1, -1}, 2, 1));
872         assertArrayEquals(
873             new short[]{(short) 0xFFFF, (short) 0xFFFF, (short) 0xF37B, (short) 0xFFFF},
874             Conversion.longToShortArray(
875                 0x1234567890ABCDEFL, 2, new short[]{-1, -1, -1, -1}, 2, 1));
876         assertArrayEquals(
877             new short[]{(short) 0xFFFF, (short) 0xFFFF, (short) 0x79BD, (short) 0xFFFF},
878             Conversion.longToShortArray(
879                 0x1234567890ABCDEFL, 3, new short[]{-1, -1, -1, -1}, 2, 1));
880         assertArrayEquals(
881             new short[]{(short) 0xFFFF, (short) 0xFFFF, (short) 0xBCDE, (short) 0xFFFF},
882             Conversion.longToShortArray(
883                 0x1234567890ABCDEFL, 4, new short[]{-1, -1, -1, -1}, 2, 1));
884         assertArrayEquals(
885             new short[]{(short) 0xE6F7, (short) 0x4855, (short) 0x2B3C, (short) 0x091A},
886             Conversion.longToShortArray(
887                 0x1234567890ABCDEFL, 1, new short[]{-1, -1, -1, -1}, 0, 4));
888         assertArrayEquals(
889             new short[]{(short) 0x2B3C},
890             Conversion.longToShortArray(0x1234567890ABCDEFL, 33, new short[]{0}, 0, 1));
891     }
892 
893     /**
894      * Tests {@link Conversion#intToShortArray(int, int, short[], int, int)}.
895      */
896     @Test
testIntToShortArray()897     public void testIntToShortArray() {
898         assertArrayEquals(
899             new short[]{}, Conversion.intToShortArray(0x00000000, 0, new short[]{}, 0, 0));
900         assertArrayEquals(
901             new short[]{}, Conversion.intToShortArray(0x00000000, 100, new short[]{}, 0, 0));
902         assertArrayEquals(
903             new short[]{}, Conversion.intToShortArray(0x00000000, 0, new short[]{}, 100, 0));
904         assertArrayEquals(
905             new short[]{(short) 0xFFFF, (short) 0xFFFF, (short) 0xFFFF, (short) 0xFFFF},
906             Conversion.intToShortArray(0x12345678, 0, new short[]{-1, -1, -1, -1}, 0, 0));
907         assertArrayEquals(
908             new short[]{(short) 0x5678, (short) 0xFFFF, (short) 0xFFFF, (short) 0xFFFF},
909             Conversion.intToShortArray(0x12345678, 0, new short[]{-1, -1, -1, -1}, 0, 1));
910         assertArrayEquals(
911             new short[]{(short) 0x5678, (short) 0x1234, (short) 0xFFFF, (short) 0xFFFF},
912             Conversion.intToShortArray(0x12345678, 0, new short[]{-1, -1, -1, -1}, 0, 2));
913         // assertArrayEquals(new
914         // short[]{(short) 0x5678, (short) 0x1234, (short) 0x5678, (short) 0xFFFF}, Conversion.intToShortArray(0x12345678,
915         // 0, new short[]{-1, -1, -1, -1}, 0, 3));//rejected by assertion
916         // assertArrayEquals(new
917         // short[]{(short) 0x5678, (short) 0x1234, (short) 0x5678, (short) 0x1234}, Conversion.intToShortArray(0x12345678,
918         // 0, new short[]{-1, -1, -1, -1}, 0, 4));
919         // assertArrayEquals(new
920         // short[]{(short) 0xFFFF, (short) 0x5678, (short) 0x1234, (short) 0x5678}, Conversion.intToShortArray(0x12345678,
921         // 0, new short[]{-1, -1, -1, -1}, 1, 3));
922         assertArrayEquals(
923             new short[]{(short) 0xFFFF, (short) 0xFFFF, (short) 0x5678, (short) 0x1234},
924             Conversion.intToShortArray(0x12345678, 0, new short[]{-1, -1, -1, -1}, 2, 2));
925         assertArrayEquals(
926             new short[]{(short) 0xFFFF, (short) 0xFFFF, (short) 0x5678, (short) 0xFFFF},
927             Conversion.intToShortArray(0x12345678, 0, new short[]{-1, -1, -1, -1}, 2, 1));
928         assertArrayEquals(
929             new short[]{(short) 0xFFFF, (short) 0xFFFF, (short) 0xFFFF, (short) 0x5678},
930             Conversion.intToShortArray(0x12345678, 0, new short[]{-1, -1, -1, -1}, 3, 1));
931         assertArrayEquals(
932             new short[]{(short) 0xFFFF, (short) 0xFFFF, (short) 0x2B3C, (short) 0xFFFF},
933             Conversion.intToShortArray(0x12345678, 1, new short[]{-1, -1, -1, -1}, 2, 1));
934         assertArrayEquals(
935             new short[]{(short) 0xFFFF, (short) 0xFFFF, (short) 0x159E, (short) 0xFFFF},
936             Conversion.intToShortArray(0x12345678, 2, new short[]{-1, -1, -1, -1}, 2, 1));
937         assertArrayEquals(
938             new short[]{(short) 0xFFFF, (short) 0xFFFF, (short) 0x8ACF, (short) 0xFFFF},
939             Conversion.intToShortArray(0x12345678, 3, new short[]{-1, -1, -1, -1}, 2, 1));
940         assertArrayEquals(
941             new short[]{(short) 0xFFFF, (short) 0xFFFF, (short) 0x4567, (short) 0xFFFF},
942             Conversion.intToShortArray(0x12345678, 4, new short[]{-1, -1, -1, -1}, 2, 1));
943         // assertArrayEquals(new
944         // short[]{(short) 0xE6F7, (short) 0x4855, (short) 0x2B3C, (short) 0x091A}, Conversion.intToShortArray(0x12345678,
945         // 1, new short[]{-1, -1, -1, -1}, 0, 4));//rejected by assertion
946         // assertArrayEquals(new
947         // short[]{(short) 0x2B3C}, Conversion.intToShortArray(0x12345678, 33, new
948         // short[]{0}, 0, 1));//rejected by assertion
949         assertArrayEquals(
950             new short[]{(short) 0x091A},
951             Conversion.intToShortArray(0x12345678, 17, new short[]{0}, 0, 1));
952     }
953 
954     /**
955      * Tests {@link Conversion#longToByteArray(long, int, byte[], int, int)}.
956      */
957     @Test
testLongToByteArray()958     public void testLongToByteArray() {
959         assertArrayEquals(
960             new byte[]{},
961             Conversion.longToByteArray(0x0000000000000000L, 0, new byte[]{}, 0, 0));
962         assertArrayEquals(
963             new byte[]{},
964             Conversion.longToByteArray(0x0000000000000000L, 100, new byte[]{}, 0, 0));
965         assertArrayEquals(
966             new byte[]{},
967             Conversion.longToByteArray(0x0000000000000000L, 0, new byte[]{}, 100, 0));
968         assertArrayEquals(
969             new byte[]{
970                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
971                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF},
972             Conversion.longToByteArray(0x1234567890ABCDEFL, 0, new byte[]{
973                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 0, 0));
974         assertArrayEquals(
975             new byte[]{
976                 (byte) 0xEF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
977                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF},
978             Conversion.longToByteArray(0x1234567890ABCDEFL, 0, new byte[]{
979                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 0, 1));
980         assertArrayEquals(
981             new byte[]{
982                 (byte) 0xEF, (byte) 0xCD, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
983                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF},
984             Conversion.longToByteArray(0x1234567890ABCDEFL, 0, new byte[]{
985                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 0, 2));
986         assertArrayEquals(
987             new byte[]{
988                 (byte) 0xEF, (byte) 0xCD, (byte) 0xAB, (byte) 0x90, (byte) 0xFF, (byte) 0xFF,
989                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF},
990             Conversion.longToByteArray(0x1234567890ABCDEFL, 0, new byte[]{
991                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 0, 4));
992         assertArrayEquals(
993             new byte[]{
994                 (byte) 0xEF, (byte) 0xCD, (byte) 0xAB, (byte) 0x90, (byte) 0x78, (byte) 0x56,
995                 (byte) 0x34, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF},
996             Conversion.longToByteArray(0x1234567890ABCDEFL, 0, new byte[]{
997                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 0, 7));
998         assertArrayEquals(
999             new byte[]{
1000                 (byte) 0xEF, (byte) 0xCD, (byte) 0xAB, (byte) 0x90, (byte) 0x78, (byte) 0x56,
1001                 (byte) 0x34, (byte) 0x12, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF},
1002             Conversion.longToByteArray(0x1234567890ABCDEFL, 0, new byte[]{
1003                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 0, 8));
1004         assertArrayEquals(
1005             new byte[]{
1006                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xEF, (byte) 0xFF, (byte) 0xFF,
1007                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF},
1008             Conversion.longToByteArray(0x1234567890ABCDEFL, 0, new byte[]{
1009                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 3, 1));
1010         assertArrayEquals(
1011             new byte[]{
1012                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xEF, (byte) 0xCD, (byte) 0xFF,
1013                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF},
1014             Conversion.longToByteArray(0x1234567890ABCDEFL, 0, new byte[]{
1015                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 3, 2));
1016         assertArrayEquals(
1017             new byte[]{
1018                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xEF, (byte) 0xCD, (byte) 0xAB,
1019                 (byte) 0x90, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF},
1020             Conversion.longToByteArray(0x1234567890ABCDEFL, 0, new byte[]{
1021                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 3, 4));
1022         assertArrayEquals(
1023             new byte[]{
1024                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xEF, (byte) 0xCD, (byte) 0xAB,
1025                 (byte) 0x90, (byte) 0x78, (byte) 0x56, (byte) 0x34, (byte) 0xFF},
1026             Conversion.longToByteArray(0x1234567890ABCDEFL, 0, new byte[]{
1027                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 3, 7));
1028         assertArrayEquals(
1029             new byte[]{
1030                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xEF, (byte) 0xCD, (byte) 0xAB,
1031                 (byte) 0x90, (byte) 0x78, (byte) 0x56, (byte) 0x34, (byte) 0x12},
1032             Conversion.longToByteArray(0x1234567890ABCDEFL, 0, new byte[]{
1033                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 3, 8));
1034         assertArrayEquals(
1035             new byte[]{
1036                 (byte) 0xF7, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
1037                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF},
1038             Conversion.longToByteArray(0x1234567890ABCDEFL, 1, new byte[]{
1039                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 0, 1));
1040         assertArrayEquals(
1041             new byte[]{
1042                 (byte) 0x7B, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
1043                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF},
1044             Conversion.longToByteArray(0x1234567890ABCDEFL, 2, new byte[]{
1045                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 0, 1));
1046         assertArrayEquals(
1047             new byte[]{
1048                 (byte) 0xFF, (byte) 0x00, (byte) 0xFF, (byte) 0x6F, (byte) 0x5E, (byte) 0x85,
1049                 (byte) 0xC4, (byte) 0xB3, (byte) 0xA2, (byte) 0x91, (byte) 0x00},
1050             Conversion.longToByteArray(0x1234567890ABCDEFL, 5, new byte[]{
1051                 -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 3, 8));
1052         // assertArrayEquals(new
1053         // 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
1054         // byte[]{-1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 3, 8));//rejected by assertion
1055         assertArrayEquals(
1056             new byte[]{
1057                 (byte) 0xFF, (byte) 0x00, (byte) 0xFF, (byte) 0x5E, (byte) 0x85, (byte) 0xC4,
1058                 (byte) 0xB3, (byte) 0xA2, (byte) 0x91, (byte) 0x00, (byte) 0xFF},
1059             Conversion.longToByteArray(0x1234567890ABCDEFL, 13, new byte[]{
1060                 -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 3, 7));
1061     }
1062 
1063     /**
1064      * Tests {@link Conversion#intToByteArray(int, int, byte[], int, int)}.
1065      */
1066     @Test
testIntToByteArray()1067     public void testIntToByteArray() {
1068         assertArrayEquals(
1069             new byte[]{}, Conversion.intToByteArray(0x00000000, 0, new byte[]{}, 0, 0));
1070         assertArrayEquals(
1071             new byte[]{}, Conversion.intToByteArray(0x00000000, 100, new byte[]{}, 0, 0));
1072         assertArrayEquals(
1073             new byte[]{}, Conversion.intToByteArray(0x00000000, 0, new byte[]{}, 100, 0));
1074         assertArrayEquals(
1075             new byte[]{
1076                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
1077                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF},
1078             Conversion.intToByteArray(0x90ABCDEF, 0, new byte[]{
1079                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 0, 0));
1080         assertArrayEquals(
1081             new byte[]{
1082                 (byte) 0xEF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
1083                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF},
1084             Conversion.intToByteArray(0x90ABCDEF, 0, new byte[]{
1085                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 0, 1));
1086         assertArrayEquals(
1087             new byte[]{
1088                 (byte) 0xEF, (byte) 0xCD, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
1089                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF},
1090             Conversion.intToByteArray(0x90ABCDEF, 0, new byte[]{
1091                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 0, 2));
1092         assertArrayEquals(
1093             new byte[]{
1094                 (byte) 0xEF, (byte) 0xCD, (byte) 0xAB, (byte) 0x90, (byte) 0xFF, (byte) 0xFF,
1095                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF},
1096             Conversion.intToByteArray(0x90ABCDEF, 0, new byte[]{
1097                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 0, 4));
1098         assertArrayEquals(
1099             new byte[]{
1100                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xEF, (byte) 0xFF, (byte) 0xFF,
1101                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF},
1102             Conversion.intToByteArray(0x90ABCDEF, 0, new byte[]{
1103                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 3, 1));
1104         assertArrayEquals(
1105             new byte[]{
1106                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xEF, (byte) 0xCD, (byte) 0xFF,
1107                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF},
1108             Conversion.intToByteArray(0x90ABCDEF, 0, new byte[]{
1109                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 3, 2));
1110         assertArrayEquals(
1111             new byte[]{
1112                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xEF, (byte) 0xCD, (byte) 0xAB,
1113                 (byte) 0x90, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF},
1114             Conversion.intToByteArray(0x90ABCDEF, 0, new byte[]{
1115                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 3, 4));
1116         assertArrayEquals(
1117             new byte[]{
1118                 (byte) 0xF7, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
1119                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF},
1120             Conversion.intToByteArray(0x90ABCDEF, 1, new byte[]{
1121                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 0, 1));
1122         assertArrayEquals(
1123             new byte[]{
1124                 (byte) 0x7B, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
1125                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF},
1126             Conversion.intToByteArray(0x90ABCDEF, 2, new byte[]{
1127                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 0, 1));
1128         assertArrayEquals(
1129             new byte[]{
1130                 (byte) 0xFF, (byte) 0x00, (byte) 0xFF, (byte) 0x6F, (byte) 0x5E, (byte) 0x85,
1131                 (byte) 0xFC, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF},
1132             Conversion.intToByteArray(0x90ABCDEF, 5, new byte[]{
1133                 -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 3, 4));
1134         // assertArrayEquals(new
1135         // byte[]{(byte) 0xFF, (byte) 0x00, (byte) 0xFF, (byte) 0x5E, (byte) 0x85, (byte) 0xFC, (byte) 0x00, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF}, Conversion.intToByteArray(0x90ABCDEF, 13, new
1136         // byte[]{-1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 3, 4));//rejected by assertion
1137         assertArrayEquals(
1138             new byte[]{
1139                 (byte) 0xFF, (byte) 0x00, (byte) 0xFF, (byte) 0x5E, (byte) 0x85, (byte) 0xFC,
1140                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF},
1141             Conversion.intToByteArray(0x90ABCDEF, 13, new byte[]{
1142                 -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 3, 3));
1143     }
1144 
1145     /**
1146      * Tests {@link Conversion#shortToByteArray(short, int, byte[], int, int)}.
1147      */
1148     @Test
testShortToByteArray()1149     public void testShortToByteArray() {
1150         assertArrayEquals(
1151             new byte[]{}, Conversion.shortToByteArray((short) 0x0000, 0, new byte[]{}, 0, 0));
1152         assertArrayEquals(
1153             new byte[]{}, Conversion.shortToByteArray((short) 0x0000, 100, new byte[]{}, 0, 0));
1154         assertArrayEquals(
1155             new byte[]{}, Conversion.shortToByteArray((short) 0x0000, 0, new byte[]{}, 100, 0));
1156         assertArrayEquals(
1157             new byte[]{
1158                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
1159                 (byte) 0xFF}, Conversion.shortToByteArray((short) 0xCDEF, 0, new byte[]{
1160                 -1, -1, -1, -1, -1, -1, -1}, 0, 0));
1161         assertArrayEquals(
1162             new byte[]{
1163                 (byte) 0xEF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
1164                 (byte) 0xFF}, Conversion.shortToByteArray((short) 0xCDEF, 0, new byte[]{
1165                 -1, -1, -1, -1, -1, -1, -1}, 0, 1));
1166         assertArrayEquals(
1167             new byte[]{
1168                 (byte) 0xEF, (byte) 0xCD, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
1169                 (byte) 0xFF}, Conversion.shortToByteArray((short) 0xCDEF, 0, new byte[]{
1170                 -1, -1, -1, -1, -1, -1, -1}, 0, 2));
1171         assertArrayEquals(
1172             new byte[]{
1173                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xEF, (byte) 0xFF, (byte) 0xFF,
1174                 (byte) 0xFF}, Conversion.shortToByteArray((short) 0xCDEF, 0, new byte[]{
1175                 -1, -1, -1, -1, -1, -1, -1}, 3, 1));
1176         assertArrayEquals(
1177             new byte[]{
1178                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xEF, (byte) 0xCD, (byte) 0xFF,
1179                 (byte) 0xFF}, Conversion.shortToByteArray((short) 0xCDEF, 0, new byte[]{
1180                 -1, -1, -1, -1, -1, -1, -1}, 3, 2));
1181         assertArrayEquals(
1182             new byte[]{
1183                 (byte) 0xF7, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
1184                 (byte) 0xFF}, Conversion.shortToByteArray((short) 0xCDEF, 1, new byte[]{
1185                 -1, -1, -1, -1, -1, -1, -1}, 0, 1));
1186         assertArrayEquals(
1187             new byte[]{
1188                 (byte) 0x7B, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
1189                 (byte) 0xFF}, Conversion.shortToByteArray((short) 0xCDEF, 2, new byte[]{
1190                 -1, -1, -1, -1, -1, -1, -1}, 0, 1));
1191         assertArrayEquals(
1192             new byte[]{
1193                 (byte) 0xFF, (byte) 0x00, (byte) 0xFF, (byte) 0x6F, (byte) 0xFE, (byte) 0xFF,
1194                 (byte) 0xFF}, Conversion.shortToByteArray((short) 0xCDEF, 5, new byte[]{
1195                 -1, 0, -1, -1, -1, -1, -1}, 3, 2));
1196         // assertArrayEquals(new
1197         // byte[]{(byte) 0xFF, (byte) 0x00, (byte) 0xFF, (byte) 0x5E, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF}, Conversion.shortToByteArray((short) 0xCDEF, 13, new
1198         // byte[]{-1, 0, -1, -1, -1, -1, -1}, 3, 2));//rejected by assertion
1199         assertArrayEquals(
1200             new byte[]{
1201                 (byte) 0xFF, (byte) 0x00, (byte) 0xFF, (byte) 0xFE, (byte) 0xFF, (byte) 0xFF,
1202                 (byte) 0xFF}, Conversion.shortToByteArray((short) 0xCDEF, 13, new byte[]{
1203                 -1, 0, -1, -1, -1, -1, -1}, 3, 1));
1204     }
1205 
1206     /**
1207      * Tests {@link Conversion#longToHex(long, int, String, int, int)}.
1208      */
1209     @Test
testLongToHex()1210     public void testLongToHex() {
1211         assertEquals("", Conversion.longToHex(0x0000000000000000L, 0, "", 0, 0));
1212         assertEquals("", Conversion.longToHex(0x0000000000000000L, 100, "", 0, 0));
1213         assertEquals("", Conversion.longToHex(0x0000000000000000L, 0, "", 100, 0));
1214         assertEquals(
1215             "ffffffffffffffffffffffff",
1216             Conversion.longToHex(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 0, 0));
1217         assertEquals(
1218             "3fffffffffffffffffffffff",
1219             Conversion.longToHex(0x1234567890ABCDE3L, 0, "ffffffffffffffffffffffff", 0, 1));
1220         assertEquals(
1221             "feffffffffffffffffffffff",
1222             Conversion.longToHex(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 0, 2));
1223         assertEquals(
1224             "fedcffffffffffffffffffff",
1225             Conversion.longToHex(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 0, 4));
1226         assertEquals(
1227             "fedcba098765432fffffffff",
1228             Conversion.longToHex(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 0, 15));
1229         assertEquals(
1230             "fedcba0987654321ffffffff",
1231             Conversion.longToHex(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 0, 16));
1232         assertEquals(
1233             "fff3ffffffffffffffffffff",
1234             Conversion.longToHex(0x1234567890ABCDE3L, 0, "ffffffffffffffffffffffff", 3, 1));
1235         assertEquals(
1236             "ffffefffffffffffffffffff",
1237             Conversion.longToHex(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 3, 2));
1238         assertEquals(
1239             "ffffedcfffffffffffffffff",
1240             Conversion.longToHex(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 3, 4));
1241         assertEquals(
1242             "ffffedcba098765432ffffff",
1243             Conversion.longToHex(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 3, 15));
1244         assertEquals(
1245             "ffffedcba0987654321fffff",
1246             Conversion.longToHex(0x1234567890ABCDEFL, 0, "ffffffffffffffffffffffff", 3, 16));
1247         assertEquals(
1248             "7fffffffffffffffffffffff",
1249             Conversion.longToHex(0x1234567890ABCDEFL, 1, "ffffffffffffffffffffffff", 0, 1));
1250         assertEquals(
1251             "bfffffffffffffffffffffff",
1252             Conversion.longToHex(0x1234567890ABCDEFL, 2, "ffffffffffffffffffffffff", 0, 1));
1253         assertEquals(
1254             "fffdb975121fca86420fffff",
1255             Conversion.longToHex(0x1234567890ABCDEFL, 3, "ffffffffffffffffffffffff", 3, 16));
1256         // assertEquals("ffffffffffffffffffffffff", Conversion.longToHex(0x1234567890ABCDEFL, 4, "ffffffffffffffffffffffff", 3, 16));//rejected
1257         // by assertion
1258         assertEquals(
1259             "fffedcba0987654321ffffff",
1260             Conversion.longToHex(0x1234567890ABCDEFL, 4, "ffffffffffffffffffffffff", 3, 15));
1261         assertEquals(
1262             "fedcba0987654321", Conversion.longToHex(0x1234567890ABCDEFL, 0, "", 0, 16));
1263         assertThrows(StringIndexOutOfBoundsException.class, () -> Conversion.longToHex(0x1234567890ABCDEFL, 0, "", 1, 8));
1264     }
1265 
1266     /**
1267      * Tests {@link Conversion#intToHex(int, int, String, int, int)}.
1268      */
1269     @Test
testIntToHex()1270     public void testIntToHex() {
1271         assertEquals("", Conversion.intToHex(0x00000000, 0, "", 0, 0));
1272         assertEquals("", Conversion.intToHex(0x00000000, 100, "", 0, 0));
1273         assertEquals("", Conversion.intToHex(0x00000000, 0, "", 100, 0));
1274         assertEquals(
1275             "ffffffffffffffffffffffff",
1276             Conversion.intToHex(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 0, 0));
1277         assertEquals(
1278             "3fffffffffffffffffffffff",
1279             Conversion.intToHex(0x90ABCDE3, 0, "ffffffffffffffffffffffff", 0, 1));
1280         assertEquals(
1281             "feffffffffffffffffffffff",
1282             Conversion.intToHex(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 0, 2));
1283         assertEquals(
1284             "fedcffffffffffffffffffff",
1285             Conversion.intToHex(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 0, 4));
1286         assertEquals(
1287             "fedcba0fffffffffffffffff",
1288             Conversion.intToHex(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 0, 7));
1289         assertEquals(
1290             "fedcba09ffffffffffffffff",
1291             Conversion.intToHex(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 0, 8));
1292         assertEquals(
1293             "fff3ffffffffffffffffffff",
1294             Conversion.intToHex(0x90ABCDE3, 0, "ffffffffffffffffffffffff", 3, 1));
1295         assertEquals(
1296             "ffffefffffffffffffffffff",
1297             Conversion.intToHex(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 3, 2));
1298         assertEquals(
1299             "ffffedcfffffffffffffffff",
1300             Conversion.intToHex(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 3, 4));
1301         assertEquals(
1302             "ffffedcba0ffffffffffffff",
1303             Conversion.intToHex(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 3, 7));
1304         assertEquals(
1305             "ffffedcba09fffffffffffff",
1306             Conversion.intToHex(0x90ABCDEF, 0, "ffffffffffffffffffffffff", 3, 8));
1307         assertEquals(
1308             "7fffffffffffffffffffffff",
1309             Conversion.intToHex(0x90ABCDEF, 1, "ffffffffffffffffffffffff", 0, 1));
1310         assertEquals(
1311             "bfffffffffffffffffffffff",
1312             Conversion.intToHex(0x90ABCDEF, 2, "ffffffffffffffffffffffff", 0, 1));
1313         assertEquals(
1314             "fffdb97512ffffffffffffff",
1315             Conversion.intToHex(0x90ABCDEF, 3, "ffffffffffffffffffffffff", 3, 8));
1316         // assertEquals("ffffffffffffffffffffffff", Conversion.intToHex(0x90ABCDEF,
1317         // 4, "ffffffffffffffffffffffff", 3, 8));//rejected by assertion
1318         assertEquals(
1319             "fffedcba09ffffffffffffff",
1320             Conversion.intToHex(0x90ABCDEF, 4, "ffffffffffffffffffffffff", 3, 7));
1321         assertEquals("fedcba09", Conversion.intToHex(0x90ABCDEF, 0, "", 0, 8));
1322         assertThrows(StringIndexOutOfBoundsException.class, () -> Conversion.intToHex(0x90ABCDEF, 0, "", 1, 8));
1323     }
1324 
1325     /**
1326      * Tests {@link Conversion#shortToHex(short, int, String, int, int)}.
1327      */
1328     @Test
testShortToHex()1329     public void testShortToHex() {
1330         assertEquals("", Conversion.shortToHex((short) 0x0000, 0, "", 0, 0));
1331         assertEquals("", Conversion.shortToHex((short) 0x0000, 100, "", 0, 0));
1332         assertEquals("", Conversion.shortToHex((short) 0x0000, 0, "", 100, 0));
1333         assertEquals(
1334             "ffffffffffffffffffffffff",
1335             Conversion.shortToHex((short) 0xCDEF, 0, "ffffffffffffffffffffffff", 0, 0));
1336         assertEquals(
1337             "3fffffffffffffffffffffff",
1338             Conversion.shortToHex((short) 0xCDE3, 0, "ffffffffffffffffffffffff", 0, 1));
1339         assertEquals(
1340             "feffffffffffffffffffffff",
1341             Conversion.shortToHex((short) 0xCDEF, 0, "ffffffffffffffffffffffff", 0, 2));
1342         assertEquals(
1343             "fedfffffffffffffffffffff",
1344             Conversion.shortToHex((short) 0xCDEF, 0, "ffffffffffffffffffffffff", 0, 3));
1345         assertEquals(
1346             "fedcffffffffffffffffffff",
1347             Conversion.shortToHex((short) 0xCDEF, 0, "ffffffffffffffffffffffff", 0, 4));
1348         assertEquals(
1349             "fff3ffffffffffffffffffff",
1350             Conversion.shortToHex((short) 0xCDE3, 0, "ffffffffffffffffffffffff", 3, 1));
1351         assertEquals(
1352             "ffffefffffffffffffffffff",
1353             Conversion.shortToHex((short) 0xCDEF, 0, "ffffffffffffffffffffffff", 3, 2));
1354         assertEquals(
1355             "7fffffffffffffffffffffff",
1356             Conversion.shortToHex((short) 0xCDEF, 1, "ffffffffffffffffffffffff", 0, 1));
1357         assertEquals(
1358             "bfffffffffffffffffffffff",
1359             Conversion.shortToHex((short) 0xCDEF, 2, "ffffffffffffffffffffffff", 0, 1));
1360         assertEquals(
1361             "fffdb9ffffffffffffffffff",
1362             Conversion.shortToHex((short) 0xCDEF, 3, "ffffffffffffffffffffffff", 3, 4));
1363         // assertEquals("ffffffffffffffffffffffff", Conversion.shortToHex((short) 0xCDEF,
1364         // 4, "ffffffffffffffffffffffff", 3, 4));//rejected by assertion
1365         assertEquals(
1366             "fffedcffffffffffffffffff",
1367             Conversion.shortToHex((short) 0xCDEF, 4, "ffffffffffffffffffffffff", 3, 3));
1368         assertEquals("fedc", Conversion.shortToHex((short) 0xCDEF, 0, "", 0, 4));
1369         assertThrows(StringIndexOutOfBoundsException.class, () -> Conversion.shortToHex((short) 0xCDEF, 0, "", 1, 4));
1370     }
1371 
1372     /**
1373      * Tests {@link Conversion#byteToHex(byte, int, String, int, int)}.
1374      */
1375     @Test
testByteToHex()1376     public void testByteToHex() {
1377         assertEquals("", Conversion.byteToHex((byte) 0x00, 0, "", 0, 0));
1378         assertEquals("", Conversion.byteToHex((byte) 0x00, 100, "", 0, 0));
1379         assertEquals("", Conversion.byteToHex((byte) 0x00, 0, "", 100, 0));
1380         assertEquals("00000", Conversion.byteToHex((byte) 0xEF, 0, "00000", 0, 0));
1381         assertEquals("f0000", Conversion.byteToHex((byte) 0xEF, 0, "00000", 0, 1));
1382         assertEquals("fe000", Conversion.byteToHex((byte) 0xEF, 0, "00000", 0, 2));
1383         assertEquals("000f0", Conversion.byteToHex((byte) 0xEF, 0, "00000", 3, 1));
1384         assertEquals("000fe", Conversion.byteToHex((byte) 0xEF, 0, "00000", 3, 2));
1385         assertEquals("70000", Conversion.byteToHex((byte) 0xEF, 1, "00000", 0, 1));
1386         assertEquals("b0000", Conversion.byteToHex((byte) 0xEF, 2, "00000", 0, 1));
1387         assertEquals("000df", Conversion.byteToHex((byte) 0xEF, 3, "00000", 3, 2));
1388         // assertEquals("00000", Conversion.byteToHex((byte) 0xEF, 4, "00000", 3, 2));//rejected by
1389         // assertion
1390         assertEquals("000e0", Conversion.byteToHex((byte) 0xEF, 4, "00000", 3, 1));
1391         assertEquals("fe", Conversion.byteToHex((byte) 0xEF, 0, "", 0, 2));
1392         assertThrows(StringIndexOutOfBoundsException.class, () -> Conversion.byteToHex((byte) 0xEF, 0, "", 1, 2));
1393     }
1394 
1395     /**
1396      * Tests {@link Conversion#longToBinary(long, int, boolean[], int, int)}.
1397      */
1398     @Test
testLongToBinary()1399     public void testLongToBinary() {
1400         assertArrayEquals(
1401             new boolean[]{},
1402             Conversion.longToBinary(0x0000000000000000L, 0, new boolean[]{}, 0, 0));
1403         assertArrayEquals(
1404             new boolean[]{},
1405             Conversion.longToBinary(0x0000000000000000L, 100, new boolean[]{}, 0, 0));
1406         assertArrayEquals(
1407             new boolean[]{},
1408             Conversion.longToBinary(0x0000000000000000L, 0, new boolean[]{}, 100, 0));
1409         assertArrayEquals(
1410             new boolean[69],
1411             Conversion.longToBinary(0x1234567890ABCDEFL, 0, new boolean[69], 0, 0));
1412 
1413         assertArrayEquals(
1414             new boolean[]{
1415                 true, false, false, false, false, false, false, false, false, false, false,
1416                 false, false, false, false, false, false, false, false, false, false, false,
1417                 false, false, false, false, false, false, false, false, false, false, false,
1418                 false, false, false, false, false, false, false, false, false, false, false,
1419                 false, false, false, false, false, false, false, false, false, false, false,
1420                 false, false, false, false, false, false, false, false, false, false, false,
1421                 false, false, false},
1422             Conversion.longToBinary(0x1234567890ABCDEFL, 0, new boolean[69], 0, 1));
1423         assertArrayEquals(
1424             new boolean[]{
1425                 true, true, false, false, false, false, false, false, false, false, false,
1426                 false, false, false, false, false, false, false, false, false, false, false,
1427                 false, false, false, false, false, false, false, false, false, false, false,
1428                 false, false, false, false, false, false, false, false, false, false, false,
1429                 false, false, false, false, false, false, false, false, false, false, false,
1430                 false, false, false, false, false, false, false, false, false, false, false,
1431                 false, false, false},
1432             Conversion.longToBinary(0x1234567890ABCDEFL, 0, new boolean[69], 0, 2));
1433         assertArrayEquals(
1434             new boolean[]{
1435                 true, true, true, false, false, false, false, false, false, false, false,
1436                 false, false, false, false, false, false, false, false, false, false, false,
1437                 false, false, false, false, false, false, false, false, false, false, false,
1438                 false, false, false, false, false, false, false, false, false, false, false,
1439                 false, false, false, false, false, false, false, false, false, false, false,
1440                 false, false, false, false, false, false, false, false, false, false, false,
1441                 false, false, false},
1442             Conversion.longToBinary(0x1234567890ABCDEFL, 0, new boolean[69], 0, 3));
1443         assertArrayEquals(
1444             new boolean[]{
1445                 true, true, true, true, false, true, true, true, true, false, true, true,
1446                 false, false, true, true, true, true, false, true, false, true, false, true,
1447                 false, false, false, false, true, false, false, true, false, false, false,
1448                 true, true, true, true, false, false, true, true, false, true, false, true,
1449                 false, false, false, true, false, true, true, false, false, false, true, false,
1450                 false, true, false, false, false, false, false, false, false, false},
1451             Conversion.longToBinary(0x1234567890ABCDEFL, 0, new boolean[69], 0, 63));
1452         assertArrayEquals(
1453             new boolean[]{
1454                 true, true, true, true, false, true, true, true, true, false, true, true,
1455                 false, false, true, true, true, true, false, true, false, true, false, true,
1456                 false, false, false, false, true, false, false, true, false, false, false,
1457                 true, true, true, true, false, false, true, true, false, true, false, true,
1458                 false, false, false, true, false, true, true, false, false, false, true, false,
1459                 false, true, false, false, false, false, false, false, false, false},
1460             Conversion.longToBinary(0x1234567890ABCDEFL, 0, new boolean[69], 0, 64));
1461         assertArrayEquals(
1462             new boolean[]{
1463                 false, false, true, false, false, false, false, false, false, false, false,
1464                 false, false, false, false, false, false, false, false, false, false, false,
1465                 false, false, false, false, false, false, false, false, false, false, false,
1466                 false, false, false, false, false, false, false, false, false, false, false,
1467                 false, false, false, false, false, false, false, false, false, false, false,
1468                 false, false, false, false, false, false, false, false, false, false, false,
1469                 false, false, false},
1470             Conversion.longToBinary(0x1234567890ABCDEFL, 0, new boolean[69], 2, 1));
1471         assertArrayEquals(
1472             new boolean[]{
1473                 false, false, true, true, true, true, false, true, true, true, true, false,
1474                 true, true, false, false, true, true, true, true, false, true, false, true,
1475                 false, true, false, false, false, false, true, false, false, true, false,
1476                 false, false, true, true, true, true, false, false, true, true, false, true,
1477                 false, true, false, false, false, true, false, true, true, false, false, false,
1478                 true, false, false, true, false, false, false, false, false, false},
1479             Conversion.longToBinary(0x1234567890ABCDEFL, 0, new boolean[69], 2, 64));
1480         assertArrayEquals(
1481             new boolean[]{
1482                 true, true, true, false, true, true, true, true, false, true, true, false,
1483                 false, true, true, true, true, false, true, false, true, false, true, false,
1484                 false, false, false, true, false, false, true, false, false, false, true, true,
1485                 true, true, false, false, true, true, false, true, false, true, false, false,
1486                 false, true, false, true, true, false, false, false, true, false, false, true,
1487                 false, false, false, false, false, false, false, false, false},
1488             Conversion.longToBinary(0x1234567890ABCDEFL, 1, new boolean[69], 0, 63));
1489         assertArrayEquals(
1490             new boolean[]{
1491                 true, true, false, true, true, true, true, false, true, true, false, false,
1492                 true, true, true, true, false, true, false, true, false, true, false, false,
1493                 false, false, true, false, false, true, false, false, false, true, true, true,
1494                 true, false, false, true, true, false, true, false, true, false, false, false,
1495                 true, false, true, true, false, false, false, true, false, false, true, false,
1496                 false, false, false, false, false, false, false, false, false},
1497             Conversion.longToBinary(0x1234567890ABCDEFL, 2, new boolean[69], 0, 62));
1498 
1499         // assertArrayEquals(new boolean[]{false, false, false, true, true, false, true, true,
1500         // true, true, false, true, true, false, false, true, true, true, true, false, true,
1501         // false, true, false, true, false, false, false, false, true, false, false, true,
1502         // false, false, false, true, true, true, true, false, false, true, true, false, true,
1503         // false, true, false, false, false, true, false, true, true, false, false, false, true,
1504         // false, false, true, false, false, false
1505         // , false, false, false, false}, Conversion.longToBinary(0x1234567890ABCDEFL, 2, new
1506         // boolean[69], 3, 63));//rejected by assertion
1507         assertArrayEquals(
1508             new boolean[]{
1509                 false, false, false, true, true, false, true, true, true, true, false, true,
1510                 true, false, false, true, true, true, true, false, true, false, true, false,
1511                 true, false, false, false, false, true, false, false, true, false, false,
1512                 false, true, true, true, true, false, false, true, true, false, true, false,
1513                 true, false, false, false, true, false, true, true, false, false, false, true,
1514                 false, false, true, false, false, false, false, false, false, false},
1515             Conversion.longToBinary(0x1234567890ABCDEFL, 2, new boolean[69], 3, 62));
1516     }
1517 
1518     /**
1519      * Tests {@link Conversion#intToBinary(int, int, boolean[], int, int)}.
1520      */
1521     @Test
testIntToBinary()1522     public void testIntToBinary() {
1523         assertArrayEquals(
1524             new boolean[]{}, Conversion.intToBinary(0x00000000, 0, new boolean[]{}, 0, 0));
1525         assertArrayEquals(
1526             new boolean[]{}, Conversion.intToBinary(0x00000000, 100, new boolean[]{}, 0, 0));
1527         assertArrayEquals(
1528             new boolean[]{}, Conversion.intToBinary(0x00000000, 0, new boolean[]{}, 100, 0));
1529         assertArrayEquals(
1530             new boolean[69], Conversion.intToBinary(0x90ABCDEF, 0, new boolean[69], 0, 0));
1531         assertArrayEquals(new boolean[]{
1532             true, false, false, false, false, false, false, false, false, false, false, false,
1533             false, false, false, false, false, false, false, false, false, false, false, false,
1534             false, false, false, false, false, false, false, false, false, false, false, false,
1535             false}, Conversion.intToBinary(0x90ABCDEF, 0, new boolean[37], 0, 1));
1536         assertArrayEquals(new boolean[]{
1537             true, true, false, false, false, false, false, false, false, false, false, false,
1538             false, false, false, false, false, false, false, false, false, false, false, false,
1539             false, false, false, false, false, false, false, false, false, false, false, false,
1540             false}, Conversion.intToBinary(0x90ABCDEF, 0, new boolean[37], 0, 2));
1541         assertArrayEquals(new boolean[]{
1542             true, true, true, false, false, false, false, false, false, false, false, false,
1543             false, false, false, false, false, false, false, false, false, false, false, false,
1544             false, false, false, false, false, false, false, false, false, false, false, false,
1545             false}, Conversion.intToBinary(0x90ABCDEF, 0, new boolean[37], 0, 3));
1546         assertArrayEquals(
1547             new boolean[]{
1548                 true, true, true, true, false, true, true, true, true, false, true, true,
1549                 false, false, true, true, true, true, false, true, false, true, false, true,
1550                 false, false, false, false, true, false, false, false, false, false, false,
1551                 false, false}, Conversion.intToBinary(0x90ABCDEF, 0, new boolean[37], 0, 31));
1552         assertArrayEquals(
1553             new boolean[]{
1554                 true, true, true, true, false, true, true, true, true, false, true, true,
1555                 false, false, true, true, true, true, false, true, false, true, false, true,
1556                 false, false, false, false, true, false, false, true, false, false, false,
1557                 false, false}, Conversion.intToBinary(0x90ABCDEF, 0, new boolean[37], 0, 32));
1558         assertArrayEquals(new boolean[]{
1559             false, false, true, false, false, false, false, false, false, false, false, false,
1560             false, false, false, false, false, false, false, false, false, false, false, false,
1561             false, false, false, false, false, false, false, false, false, false, false, false,
1562             false}, Conversion.intToBinary(0x90ABCDEF, 0, new boolean[37], 2, 1));
1563         assertArrayEquals(
1564             new boolean[]{
1565                 false, false, true, true, true, true, false, true, true, true, true, false,
1566                 true, true, false, false, true, true, true, true, false, true, false, true,
1567                 false, true, false, false, false, false, true, false, false, true, false,
1568                 false, false}, Conversion.intToBinary(0x90ABCDEF, 0, new boolean[37], 2, 32));
1569         assertArrayEquals(
1570             new boolean[]{
1571                 true, true, true, false, true, true, true, true, false, true, true, false,
1572                 false, true, true, true, true, false, true, false, true, false, true, false,
1573                 false, false, false, true, false, false, true, false, false, false, false,
1574                 false, false}, Conversion.intToBinary(0x90ABCDEF, 1, new boolean[37], 0, 31));
1575         assertArrayEquals(
1576             new boolean[]{
1577                 true, true, false, true, true, true, true, false, true, true, false, false,
1578                 true, true, true, true, false, true, false, true, false, true, false, false,
1579                 false, false, true, false, false, true, false, false, false, false, false,
1580                 false, false}, Conversion.intToBinary(0x90ABCDEF, 2, new boolean[37], 0, 30));
1581         // assertArrayEquals(new boolean[]{false, false, false, true, true, false, true,
1582         // true,
1583         // true, true, false, true, true, false, false, true, true, true, true, false, true,
1584         // false, true, false, true, false, false, false, false, true, false, false, false,
1585         // false, false, false, false}, Conversion.intToBinary(0x90ABCDEF, 2, new boolean[37],
1586         // 3, 31));//rejected by assertion
1587         assertArrayEquals(
1588             new boolean[]{
1589                 false, false, false, true, true, false, true, true, true, true, false, true,
1590                 true, false, false, true, true, true, true, false, true, false, true, false,
1591                 true, false, false, false, false, true, false, false, true, false, false,
1592                 false, false}, Conversion.intToBinary(0x90ABCDEF, 2, new boolean[37], 3, 30));
1593     }
1594 
1595     /**
1596      * Tests {@link Conversion#shortToBinary(short, int, boolean[], int, int)}.
1597      */
1598     @Test
testShortToBinary()1599     public void testShortToBinary() {
1600         assertArrayEquals(
1601             new boolean[]{}, Conversion.shortToBinary((short) 0x0000, 0, new boolean[]{}, 0, 0));
1602         assertArrayEquals(
1603             new boolean[]{},
1604             Conversion.shortToBinary((short) 0x0000, 100, new boolean[]{}, 0, 0));
1605         assertArrayEquals(
1606             new boolean[]{},
1607             Conversion.shortToBinary((short) 0x0000, 0, new boolean[]{}, 100, 0));
1608         assertArrayEquals(
1609             new boolean[69], Conversion.shortToBinary((short) 0xCDEF, 0, new boolean[69], 0, 0));
1610         assertArrayEquals(
1611             new boolean[]{
1612                 true, false, false, false, false, false, false, false, false, false, false,
1613                 false, false, false, false, false, false, false, false, false, false},
1614             Conversion.shortToBinary((short) 0xCDEF, 0, new boolean[21], 0, 1));
1615         assertArrayEquals(
1616             new boolean[]{
1617                 true, true, false, false, false, false, false, false, false, false, false,
1618                 false, false, false, false, false, false, false, false, false, false},
1619             Conversion.shortToBinary((short) 0xCDEF, 0, new boolean[21], 0, 2));
1620         assertArrayEquals(
1621             new boolean[]{
1622                 true, true, true, false, false, false, false, false, false, false, false,
1623                 false, false, false, false, false, false, false, false, false, false},
1624             Conversion.shortToBinary((short) 0xCDEF, 0, new boolean[21], 0, 3));
1625         assertArrayEquals(
1626             new boolean[]{
1627                 true, true, true, true, false, true, true, true, true, false, true, true,
1628                 false, false, true, false, false, false, false, false, false},
1629             Conversion.shortToBinary((short) 0xCDEF, 0, new boolean[21], 0, 15));
1630         assertArrayEquals(
1631             new boolean[]{
1632                 true, true, true, true, false, true, true, true, true, false, true, true,
1633                 false, false, true, true, false, false, false, false, false},
1634             Conversion.shortToBinary((short) 0xCDEF, 0, new boolean[21], 0, 16));
1635         assertArrayEquals(
1636             new boolean[]{
1637                 false, false, true, false, false, false, false, false, false, false, false,
1638                 false, false, false, false, false, false, false, false, false, false},
1639             Conversion.shortToBinary((short) 0xCDEF, 0, new boolean[21], 2, 1));
1640         assertArrayEquals(
1641             new boolean[]{
1642                 false, false, true, true, true, true, false, true, true, true, true, false,
1643                 true, true, false, false, true, true, false, false, false},
1644             Conversion.shortToBinary((short) 0xCDEF, 0, new boolean[21], 2, 16));
1645         assertArrayEquals(
1646             new boolean[]{
1647                 true, true, true, false, true, true, true, true, false, true, true, false,
1648                 false, true, true, false, false, false, false, false, false},
1649             Conversion.shortToBinary((short) 0xCDEF, 1, new boolean[21], 0, 15));
1650         assertArrayEquals(
1651             new boolean[]{
1652                 true, true, false, true, true, true, true, false, true, true, false, false,
1653                 true, true, false, false, false, false, false, false, false},
1654             Conversion.shortToBinary((short) 0xCDEF, 2, new boolean[21], 0, 14));
1655         // assertArrayEquals(new boolean[]{false, false, false, true, true, false, true, true,
1656         // true, true, false, true, true, false, false, true, false, false, false, false,
1657         // false}, Conversion.shortToBinary((short) 0xCDEF, 2, new boolean[21],
1658         // 3, 15));//rejected by
1659         // assertion
1660         assertArrayEquals(
1661             new boolean[]{
1662                 false, false, false, true, true, false, true, true, true, true, false, true,
1663                 true, false, false, true, true, false, false, false, false},
1664             Conversion.shortToBinary((short) 0xCDEF, 2, new boolean[21], 3, 14));
1665     }
1666 
1667     /**
1668      * Tests {@link Conversion#byteToBinary(byte, int, boolean[], int, int)}.
1669      */
1670     @Test
testByteToBinary()1671     public void testByteToBinary() {
1672         assertArrayEquals(
1673             new boolean[]{}, Conversion.byteToBinary((byte) 0x00, 0, new boolean[]{}, 0, 0));
1674         assertArrayEquals(
1675             new boolean[]{}, Conversion.byteToBinary((byte) 0x00, 100, new boolean[]{}, 0, 0));
1676         assertArrayEquals(
1677             new boolean[]{}, Conversion.byteToBinary((byte) 0x00, 0, new boolean[]{}, 100, 0));
1678         assertArrayEquals(
1679             new boolean[69], Conversion.byteToBinary((byte) 0xEF, 0, new boolean[69], 0, 0));
1680         assertArrayEquals(new boolean[]{
1681             true, false, false, false, false, false, false, false, false, false, false, false,
1682             false}, Conversion.byteToBinary((byte) 0x95, 0, new boolean[13], 0, 1));
1683         assertArrayEquals(new boolean[]{
1684             true, false, false, false, false, false, false, false, false, false, false, false,
1685             false}, Conversion.byteToBinary((byte) 0x95, 0, new boolean[13], 0, 2));
1686         assertArrayEquals(new boolean[]{
1687             true, false, true, false, false, false, false, false, false, false, false, false,
1688             false}, Conversion.byteToBinary((byte) 0x95, 0, new boolean[13], 0, 3));
1689         assertArrayEquals(new boolean[]{
1690             true, false, true, false, true, false, false, false, false, false, false, false,
1691             false}, Conversion.byteToBinary((byte) 0x95, 0, new boolean[13], 0, 7));
1692         assertArrayEquals(new boolean[]{
1693             true, false, true, false, true, false, false, true, false, false, false, false,
1694             false}, Conversion.byteToBinary((byte) 0x95, 0, new boolean[13], 0, 8));
1695         assertArrayEquals(new boolean[]{
1696             false, false, true, false, false, false, false, false, false, false, false, false,
1697             false}, Conversion.byteToBinary((byte) 0x95, 0, new boolean[13], 2, 1));
1698         assertArrayEquals(new boolean[]{
1699             false, false, true, false, true, false, true, false, false, true, false, false,
1700             false}, Conversion.byteToBinary((byte) 0x95, 0, new boolean[13], 2, 8));
1701         assertArrayEquals(new boolean[]{
1702             false, true, false, true, false, false, true, false, false, false, false, false,
1703             false}, Conversion.byteToBinary((byte) 0x95, 1, new boolean[13], 0, 7));
1704         assertArrayEquals(new boolean[]{
1705             true, false, true, false, false, true, false, false, false, false, false, false,
1706             false}, Conversion.byteToBinary((byte) 0x95, 2, new boolean[13], 0, 6));
1707         // assertArrayEquals(new boolean[]{false, false, false, true, true, false, true, true,
1708         // false, false, false, false, false}, Conversion.byteToBinary((byte) 0x95, 2, new
1709         // boolean[13], 3, 7));//rejected by assertion
1710         assertArrayEquals(new boolean[]{
1711             false, false, false, true, false, true, false, false, true, false, false, false,
1712             false}, Conversion.byteToBinary((byte) 0x95, 2, new boolean[13], 3, 6));
1713     }
1714 
1715     /**
1716      * Tests {@link Conversion#uuidToByteArray(UUID, byte[], int, int)}.
1717      */
1718     @Test
testUuidToByteArray()1719     public void testUuidToByteArray() {
1720         assertArrayEquals(new byte[]{
1721             (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1722             (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1723             (byte) 0xff, (byte) 0xff}, Conversion.uuidToByteArray(new UUID(
1724             0xFFFFFFFFFFFFFFFFL, 0xFFFFFFFFFFFFFFFFL), new byte[16], 0, 16));
1725         assertArrayEquals(new byte[]{
1726             (byte) 0x88, (byte) 0x99, (byte) 0xaa, (byte) 0xbb, (byte) 0xcc, (byte) 0xdd, (byte) 0xee,
1727             (byte) 0xff, (byte) 0x00, (byte) 0x11, (byte) 0x22, (byte) 0x33, (byte) 0x44, (byte) 0x55,
1728             (byte) 0x66, (byte) 0x77}, Conversion.uuidToByteArray(new UUID(
1729             0xFFEEDDCCBBAA9988L, 0x7766554433221100L), new byte[16], 0, 16));
1730         assertArrayEquals(new byte[]{
1731             (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x88, (byte) 0x99, (byte) 0xaa,
1732             (byte) 0xbb, (byte) 0xcc, (byte) 0xdd, (byte) 0xee, (byte) 0xff, (byte) 0x00, (byte) 0x00,
1733             (byte) 0x00, (byte) 0x00}, Conversion.uuidToByteArray(new UUID(
1734             0xFFEEDDCCBBAA9988L, 0x7766554433221100L), new byte[16], 4, 8));
1735         assertArrayEquals(new byte[]{
1736             (byte) 0x00, (byte) 0x00, (byte) 0x88, (byte) 0x99, (byte) 0xaa, (byte) 0xbb, (byte) 0xcc,
1737             (byte) 0xdd, (byte) 0xee, (byte) 0xff, (byte) 0x00, (byte) 0x11, (byte) 0x22, (byte) 0x33,
1738             (byte) 0x00, (byte) 0x00}, Conversion.uuidToByteArray(new UUID(
1739             0xFFEEDDCCBBAA9988L, 0x7766554433221100L), new byte[16], 2, 12));
1740     }
1741 
1742     /**
1743      * Tests {@link Conversion#byteArrayToUuid(byte[], int)}.
1744      */
1745     @Test
testByteArrayToUuid()1746     public void testByteArrayToUuid() {
1747         assertEquals(
1748             new UUID(0xFFFFFFFFFFFFFFFFL, 0xFFFFFFFFFFFFFFFFL),
1749             Conversion.byteArrayToUuid(new byte[]{
1750                 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1751                 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1752                 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff}, 0));
1753         assertEquals(
1754             new UUID(0xFFEEDDCCBBAA9988L, 0x7766554433221100L),
1755             Conversion.byteArrayToUuid(new byte[]{
1756                 (byte) 0x88, (byte) 0x99, (byte) 0xaa, (byte) 0xbb, (byte) 0xcc, (byte) 0xdd,
1757                 (byte) 0xee, (byte) 0xff, (byte) 0x00, (byte) 0x11, (byte) 0x22, (byte) 0x33,
1758                 (byte) 0x44, (byte) 0x55, (byte) 0x66, (byte) 0x77}, 0));
1759         assertEquals(
1760             new UUID(0xFFEEDDCCBBAA9988L, 0x7766554433221100L),
1761             Conversion.byteArrayToUuid(new byte[]{
1762                 0, 0, (byte) 0x88, (byte) 0x99, (byte) 0xaa, (byte) 0xbb, (byte) 0xcc, (byte) 0xdd,
1763                 (byte) 0xee, (byte) 0xff, (byte) 0x00, (byte) 0x11, (byte) 0x22, (byte) 0x33,
1764                 (byte) 0x44, (byte) 0x55, (byte) 0x66, (byte) 0x77}, 2));
1765     }
1766 }
1767