2 * Copyright (c) 2014, 2015 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
9 package org.opendaylight.openflowplugin.libraries.liblldp;
11 import org.junit.Assert;
12 import org.junit.Ignore;
13 import org.junit.Test;
15 public class BitBufferHelperTest {
17 public void testToNumberNominal() {
18 byte[] array = new byte[] { -1, -1, -1, -1 };
20 for (int i = 0; i < 32; i++) {
21 Assert.assertEquals(expected, BitBufferHelper.toNumber(array, i));
27 public void testToNumberWithSmallArray() {
28 byte[] array = new byte[] { -1 };
30 for (int i = 0; i < 32; i++) {
31 Assert.assertEquals(expected, BitBufferHelper.toNumber(array, i));
39 public void testGetByte() {
40 byte[] data = { 100 };
41 Assert.assertEquals(100, BitBufferHelper.getByte(data));
45 public void testGetBits() throws Exception {
46 byte[] data = { 10, 12, 14, 20, 55, 69, 82, 97, 109, 117, 127, -50 };
49 bits = BitBufferHelper.getBits(data, 88, 8); //BYTE extraOffsetBits = extranumBits = 0
50 Assert.assertEquals(bits[0], -50);
52 bits = BitBufferHelper.getBits(data, 8, 16); //Short
53 Assert.assertEquals(12, bits[0]);
54 Assert.assertEquals(14, bits[1]);
56 bits = BitBufferHelper.getBits(data, 32, 32); //Int
57 Assert.assertEquals(55, bits[0]);
58 Assert.assertEquals(69, bits[1]);
59 Assert.assertEquals(82, bits[2]);
60 Assert.assertEquals(97, bits[3]);
62 bits = BitBufferHelper.getBits(data, 16, 48); //Long
63 Assert.assertEquals(14, bits[0]);
64 Assert.assertEquals(20, bits[1]);
65 Assert.assertEquals(55, bits[2]);
66 Assert.assertEquals(69, bits[3]);
67 Assert.assertEquals(82, bits[4]);
68 Assert.assertEquals(97, bits[5]);
70 bits = BitBufferHelper.getBits(data, 40, 7); //BYTE extraOffsetBits = extranumBits != 0
71 Assert.assertEquals(34, bits[0]);
73 bits = BitBufferHelper.getBits(data, 8, 13); //Short
74 Assert.assertEquals(1, bits[0]);
75 Assert.assertEquals(bits[1], -127);
77 bits = BitBufferHelper.getBits(data, 32, 28); //Int
78 Assert.assertEquals(3, bits[0]);
79 Assert.assertEquals(116, bits[1]);
80 Assert.assertEquals(85, bits[2]);
81 Assert.assertEquals(38, bits[3]);
83 bits = BitBufferHelper.getBits(data, 16, 41); //Long
84 Assert.assertEquals(0, bits[0]);
85 Assert.assertEquals(28, bits[1]);
86 Assert.assertEquals(40, bits[2]);
87 Assert.assertEquals(110, bits[3]);
88 Assert.assertEquals(bits[4], -118);
89 Assert.assertEquals(bits[5], -92);
91 bits = BitBufferHelper.getBits(data, 3, 7); //BYTE extraOffsetBits != 0; extranumBits == 0
92 Assert.assertEquals(40, bits[0]);
94 bits = BitBufferHelper.getBits(data, 13, 16); //Short
95 Assert.assertEquals(bits[0], -127);
96 Assert.assertEquals(bits[1], -62);
98 bits = BitBufferHelper.getBits(data, 5, 32); //Int
99 Assert.assertEquals(65, bits[0]);
100 Assert.assertEquals(bits[1], -127);
101 Assert.assertEquals(bits[2], -62);
102 Assert.assertEquals(bits[3], -122);
104 bits = BitBufferHelper.getBits(data, 23, 48); //Long
105 Assert.assertEquals(10, bits[0]);
106 Assert.assertEquals(27, bits[1]);
107 Assert.assertEquals(bits[2], -94);
108 Assert.assertEquals(bits[3], -87);
109 Assert.assertEquals(48, bits[4]);
110 Assert.assertEquals(bits[5], -74);
112 bits = BitBufferHelper.getBits(data, 66, 9); //BYTE extraOffsetBits != 0; extranumBits != 0
113 Assert.assertEquals(1, bits[0]);
114 Assert.assertEquals(107, bits[1]);
116 bits = BitBufferHelper.getBits(data, 13, 15); //Short
117 Assert.assertEquals(64, bits[0]);
118 Assert.assertEquals(bits[1], -31);
120 bits = BitBufferHelper.getBits(data, 5, 29); //Int
121 Assert.assertEquals(8, bits[0]);
122 Assert.assertEquals(48, bits[1]);
123 Assert.assertEquals(56, bits[2]);
124 Assert.assertEquals(80, bits[3]);
126 bits = BitBufferHelper.getBits(data, 31, 43); //Long
127 Assert.assertEquals(0, bits[0]);
128 Assert.assertEquals(bits[1], -35);
129 Assert.assertEquals(21, bits[2]);
130 Assert.assertEquals(73, bits[3]);
131 Assert.assertEquals(bits[4], -123);
132 Assert.assertEquals(bits[5], -75);
134 bits = BitBufferHelper.getBits(data, 4, 12); //Short
135 Assert.assertEquals(10, bits[0]);
136 Assert.assertEquals(12, bits[1]);
138 byte[] data1 = { 0, 8 };
139 bits = BitBufferHelper.getBits(data1, 7, 9); //Short
140 Assert.assertEquals(0, bits[0]);
141 Assert.assertEquals(8, bits[1]);
143 byte[] data2 = { 2, 8 };
144 bits = BitBufferHelper.getBits(data2, 0, 7); //Short
145 Assert.assertEquals(1, bits[0]);
147 bits = BitBufferHelper.getBits(data2, 7, 9); //Short
148 Assert.assertEquals(0, bits[0]);
149 Assert.assertEquals(8, bits[1]);
152 // [01101100][01100000]
155 public void testGetBytes() throws Exception {
156 byte[] data = { 108, 96, 125, -112, 5, 6, 108, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22 };
158 Assert.assertEquals(108, BitBufferHelper.getBits(data, 0, 8)[0]);
159 Assert.assertEquals(96, BitBufferHelper.getBits(data, 8, 8)[0]);
161 byte[] bits = BitBufferHelper.getBits(data, 0, 10);
162 Assert.assertEquals(1, bits[0]);
163 Assert.assertEquals(bits[1], -79);
165 bits = BitBufferHelper.getBits(data, 3, 8);
166 Assert.assertEquals(99, bits[0]);
167 //Assert.assertTrue(x[1] == 97);
172 public void testMSBMask() {
173 int numBits = 1; //MSB
174 int mask = BitBufferHelper.getMSBMask(numBits);
175 Assert.assertEquals(128, mask);
178 mask = BitBufferHelper.getMSBMask(numBits);
179 Assert.assertEquals(255, mask);
182 mask = BitBufferHelper.getMSBMask(numBits);
183 Assert.assertEquals(192, mask);
187 public void testLSBMask() {
188 int numBits = 1; //LSB
189 int mask = BitBufferHelper.getLSBMask(numBits);
190 Assert.assertEquals(1, mask);
193 mask = BitBufferHelper.getLSBMask(numBits);
194 Assert.assertEquals(7, mask);
197 mask = BitBufferHelper.getLSBMask(numBits);
198 Assert.assertEquals(255, mask);
202 public void testToByteArray() {
203 short sh = Short.MAX_VALUE;
204 byte[] dataShort = BitBufferHelper.toByteArray(sh);
205 Assert.assertEquals(127, dataShort[0]);
206 Assert.assertEquals(dataShort[1], -1);
208 short sh2 = Short.MIN_VALUE;
209 byte[] dataShort2 = BitBufferHelper.toByteArray(sh2);
210 Assert.assertEquals(dataShort2[0], -128);
211 Assert.assertEquals(0, dataShort2[1]);
214 byte[] dataShort3 = BitBufferHelper.toByteArray(sh3);
215 Assert.assertEquals(64, dataShort3[0]);
216 Assert.assertEquals(0, dataShort3[1]);
218 short sh4 = 146; //TCP headerlenflags - startoffset = 103
219 byte[] dataShort4 = BitBufferHelper.toByteArray(sh4);
220 Assert.assertEquals(0, dataShort4[0]);
221 Assert.assertEquals(dataShort4[1], -110);
223 short sh5 = 5000; //IPv4 Offset - startOffset = 51 (to 63)
224 byte[] dataShort5 = BitBufferHelper.toByteArray(sh5);
225 Assert.assertEquals(19, dataShort5[0]);
226 Assert.assertEquals(dataShort5[1], -120);
228 short sh6 = 5312; //numEndRestBits < numBitstoShiftBy
229 byte[] dataShort6 = BitBufferHelper.toByteArray(sh6);
230 Assert.assertEquals(20, dataShort6[0]);
231 Assert.assertEquals(dataShort6[1], -64);
233 int int1 = Integer.MAX_VALUE;
234 byte[] dataInt1 = BitBufferHelper.toByteArray(int1);
235 Assert.assertEquals(127, dataInt1[0]);
236 Assert.assertEquals(dataInt1[1], -1);
237 Assert.assertEquals(dataInt1[2], -1);
238 Assert.assertEquals(dataInt1[3], -1);
240 int int2 = Integer.MIN_VALUE;
241 byte[] dataInt2 = BitBufferHelper.toByteArray(int2);
242 Assert.assertEquals(dataInt2[0], -128);
243 Assert.assertEquals(0, dataInt2[1]);
244 Assert.assertEquals(0, dataInt2[2]);
245 Assert.assertEquals(0, dataInt2[3]);
247 int int3 = 1077952576;
248 byte[] dataInt3 = BitBufferHelper.toByteArray(int3);
249 Assert.assertEquals(64, dataInt3[0]);
250 Assert.assertEquals(64, dataInt3[1]);
251 Assert.assertEquals(64, dataInt3[2]);
252 Assert.assertEquals(64, dataInt3[3]);
254 long long1 = Long.MAX_VALUE;
255 byte[] dataLong1 = BitBufferHelper.toByteArray(long1);
256 Assert.assertEquals(127, dataLong1[0]);
257 Assert.assertEquals(dataLong1[1], -1);
258 Assert.assertEquals(dataLong1[2], -1);
259 Assert.assertEquals(dataLong1[3], -1);
260 Assert.assertEquals(dataLong1[4], -1);
261 Assert.assertEquals(dataLong1[5], -1);
262 Assert.assertEquals(dataLong1[6], -1);
263 Assert.assertEquals(dataLong1[7], -1);
265 long long2 = Long.MIN_VALUE;
266 byte[] dataLong2 = BitBufferHelper.toByteArray(long2);
267 Assert.assertEquals(dataLong2[0], -128);
268 Assert.assertEquals(0, dataLong2[1]);
269 Assert.assertEquals(0, dataLong2[2]);
270 Assert.assertEquals(0, dataLong2[3]);
271 Assert.assertEquals(0, dataLong2[4]);
272 Assert.assertEquals(0, dataLong2[5]);
273 Assert.assertEquals(0, dataLong2[6]);
274 Assert.assertEquals(0, dataLong2[7]);
276 byte byte1 = Byte.MAX_VALUE;
277 byte[] dataByte1 = BitBufferHelper.toByteArray(byte1);
278 Assert.assertEquals(127, dataByte1[0]);
280 byte byte2 = Byte.MIN_VALUE;
281 byte[] dataByte2 = BitBufferHelper.toByteArray(byte2);
282 Assert.assertEquals(dataByte2[0], -128);
285 byte[] dataByte3 = BitBufferHelper.toByteArray(byte3);
286 Assert.assertEquals(64, dataByte3[0]);
289 byte[] dataByte4 = BitBufferHelper.toByteArray(byte4);
290 Assert.assertEquals(32, dataByte4[0]);
295 public void testToByteArrayVariable() {
298 dataShort = BitBufferHelper.toByteArray(511, len);
299 Assert.assertEquals(dataShort[0], (byte) 255);
300 Assert.assertEquals(dataShort[1], (byte) 128);
302 dataShort = BitBufferHelper.toByteArray(511, len);
303 Assert.assertEquals(dataShort[0], (byte) 255);
304 Assert.assertEquals(dataShort[1], (byte) 128);
306 dataShort = BitBufferHelper.toByteArray((long) 511, len);
307 Assert.assertEquals(dataShort[0], (byte) 255);
308 Assert.assertEquals(dataShort[1], (byte) 128);
312 public void testToInt() {
314 Assert.assertEquals(1, BitBufferHelper.toNumber(data));
316 byte[] data2 = { 1, 1 };
317 Assert.assertEquals(257, BitBufferHelper.toNumber(data2));
319 byte[] data3 = { 1, 1, 1 };
320 Assert.assertEquals(65793, BitBufferHelper.toNumber(data3));
324 public void testToLongGetter() {
325 byte[] data = { 1, 1 };
326 Assert.assertEquals(257L, BitBufferHelper.getLong(data));
330 public void testSetByte() throws Exception {
332 byte[] data = new byte[20];
335 BitBufferHelper.setByte(data, input, 0, Byte.SIZE);
336 Assert.assertEquals(125, data[0]);
339 BitBufferHelper.setByte(data, input, 152, Byte.SIZE);
340 Assert.assertEquals(109, data[19]);
344 public void testSetBytes() throws Exception {
345 byte[] input = { 0, 1 };
346 byte[] data = { 6, 0 };
348 BitBufferHelper.setBytes(data, input, 7, 9);
349 Assert.assertEquals(6, data[0]);
350 Assert.assertEquals(1, data[1]);
354 @Ignore("Currently broken")
355 //INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
356 // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]*/
357 public void testInsertBits() {
358 //CASE 1: startOffset%8 == 0 && numBits%8 == 0
359 byte[] inputdata = { 75, 110, 107, 80, 10, 12, 35, 100, 125, 65 };
363 byte[] data1 = new byte[2];
366 BitBufferHelper.insertBits(data1, inputdata, startOffset, numBits);
367 Assert.assertEquals(75, data1[0]);
368 Assert.assertEquals(110, data1[1]);
370 byte[] data2 = new byte[4];
373 BitBufferHelper.insertBits(data2, inputdata, startOffset, numBits);
374 Assert.assertEquals(75, data2[0]);
375 Assert.assertEquals(110, data2[1]);
376 Assert.assertEquals(107, data2[2]);
377 Assert.assertEquals(80, data2[3]);
379 // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
380 // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
381 // OUTPUT: [01001011] [01101000] = {75, 104}
382 byte[] data10 = new byte[2];
385 BitBufferHelper.insertBits(data10, inputdata, startOffset, numBits);
386 Assert.assertEquals(75, data10[0]);
387 Assert.assertEquals(104, data10[1]);
389 // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
390 // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
391 // OUTPUT: [01001000] = {72}
392 byte[] data11 = new byte[4];
395 BitBufferHelper.insertBits(data11, inputdata, startOffset, numBits);
396 Assert.assertEquals(72, data11[1]);
398 // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
399 // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
400 // OUTPUT: [01001011] [01101110] [01101000] = {75, 110, 105}
401 byte[] data12 = new byte[4];
404 BitBufferHelper.insertBits(data12, inputdata, startOffset, numBits);
405 Assert.assertEquals(75, data12[0]);
406 Assert.assertEquals(110, data12[1]);
407 Assert.assertEquals(106, data12[2]);
409 // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
410 // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
411 // OUTPUT: [01001011] [01101110] [01100000] = {75, 110, 96}
412 byte[] data13 = new byte[4];
415 BitBufferHelper.insertBits(data13, inputdata, startOffset, numBits);
416 Assert.assertEquals(75, data13[1]);
417 Assert.assertEquals(110, data13[2]);
418 Assert.assertEquals(96, data13[3]);
420 // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
421 // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
422 // OUTPUT: [01001011] [01101110] [01101011] [10100000]= {75, 110, 107, 80}
423 byte[] data14 = new byte[4];
426 BitBufferHelper.insertBits(data14, inputdata, startOffset, numBits);
427 Assert.assertEquals(75, data14[0]);
428 Assert.assertEquals(110, data14[1]);
429 Assert.assertEquals(107, data14[2]);
430 Assert.assertEquals(80, data14[3]);
432 //CASE 3: startOffset%8 != 0, numBits%8 = 0
433 // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
434 // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
435 // OUTPUT: [00001001] [11000000] = {72, 96}
436 byte[] data16 = new byte[5];
439 BitBufferHelper.insertBits(data16, inputdata, startOffset, numBits);
440 Assert.assertEquals(9, data16[0]);
441 Assert.assertEquals(96, data16[1]);
442 Assert.assertEquals(0, data16[2]);
444 // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
445 // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
446 // OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
447 // OUTPUT: [00000100] [1011 0110] [1110 0000] = {4, -54, -96}
451 byte[] data17 = new byte[5];
452 BitBufferHelper.insertBits(data17, inputdata, startOffset, numBits);
453 Assert.assertEquals(9, data17[0]);
454 Assert.assertEquals(109, data17[1]);
455 Assert.assertEquals(data17[2], -64);
456 Assert.assertEquals(0, data17[3]);
458 // INPUT: {79, 110, 111}
459 // = [01001111] [01101110] [01101111]
460 //OUTPUT: [0000 1001] [1110 1101] [110 00000] = {9, -19, -64}
461 byte[] data18 = new byte[5];
462 byte[] inputdata3 = { 79, 110, 111 };
465 BitBufferHelper.insertBits(data18, inputdata3, startOffset, numBits);
466 Assert.assertEquals(9, data18[0]);
467 Assert.assertEquals(data18[1], -19);
468 Assert.assertEquals(data18[2], -64);
470 // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
471 // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
472 // OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
473 // OUTPUT: [0000 1001] [0110 1101] [1100 1101] [0110 1010] [0000 0001] = {9, 109, -51, 106, 0}
477 byte[] data19 = new byte[5];
478 BitBufferHelper.insertBits(data19, inputdata, startOffset, numBits);
479 Assert.assertEquals(9, data19[0]);
480 Assert.assertEquals(109, data19[1]);
481 Assert.assertEquals(data19[2], -51);
482 Assert.assertEquals(106, data19[3]);
483 Assert.assertEquals(0, data19[4]);
485 // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
486 // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
487 // OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
488 // OUTPUT: data[4, 5, 6] = [0 010 0101] [1 011 0111] [0 000 0000] = {37, -73, 0}
491 byte[] data20 = new byte[7];
492 BitBufferHelper.insertBits(data20, inputdata, startOffset, numBits);
493 Assert.assertEquals(37, data20[4]);
494 Assert.assertEquals(data20[5], -73);
495 Assert.assertEquals(0, data20[6]);
497 //CASE 4: extranumBits != 0 AND extraOffsetBits != 0
498 // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
499 // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
500 // OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
501 // OUTPUT: [0000 1001] [0100 0000] = {9, 96}
504 byte[] data21 = new byte[7];
505 BitBufferHelper.insertBits(data21, inputdata, startOffset, numBits);
506 Assert.assertEquals(9, data21[0]);
507 Assert.assertEquals(64, data21[1]);
508 Assert.assertEquals(0, data21[2]);
510 // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
511 // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
512 // OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
513 // OUTPUT: data = [00000 010] [01011 011] [01110 000] = {37, -73, 0}
516 byte[] data22 = new byte[7];
517 BitBufferHelper.insertBits(data22, inputdata, startOffset, numBits);
518 Assert.assertEquals(2, data22[0]);
519 Assert.assertEquals(91, data22[1]);
520 Assert.assertEquals(112, data22[2]);
522 // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
523 // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
524 // OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
525 // OUTPUT: [0000 1001] [0110 1101] [110 01101] [01 00000] = {9, 109, -51, 64}
528 byte[] data23 = new byte[7];
529 BitBufferHelper.insertBits(data23, inputdata, startOffset, numBits);
530 Assert.assertEquals(9, data23[0]);
531 Assert.assertEquals(109, data23[1]);
532 Assert.assertEquals(data23[2], -51);
533 Assert.assertEquals(64, data23[3]);
535 // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
536 // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
537 // OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
538 // OUTPUT: [0000 1001] [0110 1101] = {9, 109}
541 byte[] data24 = new byte[7];
542 BitBufferHelper.insertBits(data24, inputdata, startOffset, numBits);
543 Assert.assertEquals(9, data24[0]);
544 Assert.assertEquals(109, data24[1]);
545 Assert.assertEquals(0, data24[2]);
547 // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
548 // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
549 // OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
550 // OUTPUT: [0000 0100] [1011 0110] [1110 0110] = {4, -74, -26}
553 byte[] data25 = new byte[7];
554 BitBufferHelper.insertBits(data25, inputdata, startOffset, numBits);
555 Assert.assertEquals(4, data25[0]);
556 Assert.assertEquals(data25[1], -74);
557 Assert.assertEquals(data25[2], -26);
558 Assert.assertEquals(data25[3], -0);
560 // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
561 // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
562 // OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
563 // OUTPUT: [0000 0010] [0101 1011] = {0, 2, 91, 0}
566 byte[] data26 = new byte[7];
567 BitBufferHelper.insertBits(data26, inputdata, startOffset, numBits);
568 Assert.assertEquals(0, data26[0]);
569 Assert.assertEquals(2, data26[1]);
570 Assert.assertEquals(91, data26[2]);
571 Assert.assertEquals(0, data26[3]);
573 // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
574 // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
575 // OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
576 // OUTPUT: [000 01001] [011 01101] [110 0 0000] = {9, 109, -64, 0}
579 byte[] data27 = new byte[7];
580 BitBufferHelper.insertBits(data27, inputdata, startOffset, numBits);
581 Assert.assertEquals(9, data27[0]);
582 Assert.assertEquals(109, data27[1]);
583 Assert.assertEquals(data27[2], -64);
584 Assert.assertEquals(0, data27[3]);
586 // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
587 // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
588 // OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
589 // OUTPUT: [00 000000] [00 000000] [00 010010] [11 011011] [10 011010] [11 010100] [0000 0000] =
590 // {0, 0, 18, -37,-102,-44,0}
593 byte[] data28 = new byte[7];
594 BitBufferHelper.insertBits(data28, inputdata, startOffset, numBits);
595 Assert.assertEquals(0, data28[0]);
596 Assert.assertEquals(0, data28[1]);
597 Assert.assertEquals(18, data28[2]);
598 Assert.assertEquals(data28[3], -37);
599 Assert.assertEquals(data28[4], -102);
600 Assert.assertEquals(data28[5], -44);
601 Assert.assertEquals(0, data28[6]);
606 public void testGetShort() {
607 byte[] data = new byte[2];
610 int length = 9; // num bits
611 Assert.assertEquals(264, BitBufferHelper.getShort(data, length));
615 short result = BitBufferHelper.getShort(data, length);
616 Assert.assertEquals(8, result);
620 result = BitBufferHelper.getShort(data, length);
621 Assert.assertEquals(47, result);
623 //[0000 0001] [0001 0100] [0110 0100]
624 byte[] data1 = new byte[2];
626 data1[1] = 20; //data1[2] = 100;
628 result = BitBufferHelper.getShort(data1, length);
629 Assert.assertEquals(276, result);
631 byte[] data2 = new byte[2];
633 data2[1] = 99; //data2[2] = 100;
635 result = BitBufferHelper.getShort(data2, length);
636 Assert.assertEquals(99, result);
638 byte[] data3 = { 100, 50 };
639 result = BitBufferHelper.getShort(data3);
640 Assert.assertEquals(25650, result);
644 public void testToIntVarLength() {
645 byte[] data = { (byte) 255, (byte) 128 };
646 int length = 9; // num bits
647 Assert.assertEquals(384, BitBufferHelper.getInt(data, length));
649 byte[] data2 = { 0, 8 };
650 Assert.assertEquals(8, BitBufferHelper.getInt(data2, 9));
652 byte[] data3 = { 1, 1, 1 };
653 Assert.assertEquals(65793, BitBufferHelper.getInt(data3));
655 byte[] data4 = { 1, 1, 1 };
656 Assert.assertEquals(65793, BitBufferHelper.getInt(data4));
658 byte[] data5 = { 1, 1 };
659 Assert.assertEquals(257, BitBufferHelper.getInt(data5));
664 public void testShiftBitstoLSB() {
665 byte[] data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
667 byte[] data2 = { 8, 9, 10 };
668 byte[] shiftedBytes2 = BitBufferHelper.shiftBitsToLSB(data2, 11);
670 Assert.assertEquals(0, shiftedBytes2[0]);
671 Assert.assertEquals(64, shiftedBytes2[1]);
672 Assert.assertEquals(72, shiftedBytes2[2]);
674 byte[] shiftedBytes = BitBufferHelper.shiftBitsToLSB(data, 49);
676 Assert.assertEquals(0, shiftedBytes[0]);
677 Assert.assertEquals(2, shiftedBytes[1]);
678 Assert.assertEquals(4, shiftedBytes[2]);
679 Assert.assertEquals(6, shiftedBytes[3]);
680 Assert.assertEquals(8, shiftedBytes[4]);
681 Assert.assertEquals(10, shiftedBytes[5]);
682 Assert.assertEquals(12, shiftedBytes[6]);
683 Assert.assertEquals(14, shiftedBytes[7]);
684 Assert.assertEquals(16, shiftedBytes[8]);
685 Assert.assertEquals(18, shiftedBytes[9]);
687 byte[] data1 = { 1, 2, 3 };
688 byte[] shiftedBytes1 = BitBufferHelper.shiftBitsToLSB(data1, 18);
689 Assert.assertEquals(0, shiftedBytes1[0]);
690 Assert.assertEquals(4, shiftedBytes1[1]);
691 Assert.assertEquals(8, shiftedBytes1[2]);
696 public void testShiftBitsToLSBAndMSB() {
697 byte[] data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
699 byte[] clone = BitBufferHelper.shiftBitsToMSB(BitBufferHelper
700 .shiftBitsToLSB(data, 72), 72);
702 Assert.assertEquals(1, clone[0]);
703 Assert.assertEquals(2, clone[1]);
704 Assert.assertEquals(3, clone[2]);
705 Assert.assertEquals(4, clone[3]);
706 Assert.assertEquals(5, clone[4]);
707 Assert.assertEquals(6, clone[5]);
708 Assert.assertEquals(7, clone[6]);
709 Assert.assertEquals(8, clone[7]);
710 Assert.assertEquals(9, clone[8]);
711 Assert.assertEquals(0, clone[9]);