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