libraries/liblldp/src/test/java/org/opendaylight/openflowplugin/libraries/liblldp/BitBufferHelperTest.java

   1 /*
   2  * Copyright (c) 2014, 2015 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   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
   7  */
   8
   9 package org.opendaylight.openflowplugin.libraries.liblldp;
  10
  11 import org.junit.Assert;
  12 import org.junit.Ignore;
  13 import org.junit.Test;
  14
  15 public class BitBufferHelperTest {
  16     @Test
  17     public void testToNumberNominal() {
  18         byte[] array = new byte[] { -1, -1, -1, -1 };
  19         long expected = 0;
  20         for (int i = 0; i < 32; i++) {
  21             Assert.assertEquals(expected, BitBufferHelper.toNumber(array, i));
  22             expected += 1 << i;
  23         }
  24     }
  25
  26     @Test
  27     public void testToNumberWithSmallArray() {
  28         byte[] array = new byte[] { -1 };
  29         long expected = 0;
  30         for (int i = 0; i < 32; i++) {
  31             Assert.assertEquals(expected, BitBufferHelper.toNumber(array, i));
  32             if (i < 8) {
  33                 expected += 1 << i;
  34             }
  35         }
  36     }
  37
  38     @Test
  39     public void testGetByte() {
  40         byte[] data = { 100 };
  41         Assert.assertEquals(100, BitBufferHelper.getByte(data));
  42     }
  43
  44     @Test
  45     public void testGetBits() throws Exception {
  46         byte[] data = { 10, 12, 14, 20, 55, 69, 82, 97, 109, 117, 127, -50 };
  47         byte[] bits;
  48
  49         bits = BitBufferHelper.getBits(data, 88, 8); //BYTE extraOffsetBits = extranumBits = 0
  50         Assert.assertEquals(bits[0], -50);
  51
  52         bits = BitBufferHelper.getBits(data, 8, 16); //Short
  53         Assert.assertEquals(12, bits[0]);
  54         Assert.assertEquals(14, bits[1]);
  55
  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]);
  61
  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]);
  69
  70         bits = BitBufferHelper.getBits(data, 40, 7); //BYTE extraOffsetBits = extranumBits != 0
  71         Assert.assertEquals(34, bits[0]);
  72
  73         bits = BitBufferHelper.getBits(data, 8, 13); //Short
  74         Assert.assertEquals(1, bits[0]);
  75         Assert.assertEquals(bits[1], -127);
  76
  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]);
  82
  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);
  90
  91         bits = BitBufferHelper.getBits(data, 3, 7); //BYTE extraOffsetBits != 0; extranumBits == 0
  92         Assert.assertEquals(40, bits[0]);
  93
  94         bits = BitBufferHelper.getBits(data, 13, 16); //Short
  95         Assert.assertEquals(bits[0], -127);
  96         Assert.assertEquals(bits[1], -62);
  97
  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);
 103
 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);
 111
 112         bits = BitBufferHelper.getBits(data, 66, 9); //BYTE extraOffsetBits != 0; extranumBits != 0
 113         Assert.assertEquals(1, bits[0]);
 114         Assert.assertEquals(107, bits[1]);
 115
 116         bits = BitBufferHelper.getBits(data, 13, 15); //Short
 117         Assert.assertEquals(64, bits[0]);
 118         Assert.assertEquals(bits[1], -31);
 119
 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]);
 125
 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);
 133
 134         bits = BitBufferHelper.getBits(data, 4, 12); //Short
 135         Assert.assertEquals(10, bits[0]);
 136         Assert.assertEquals(12, bits[1]);
 137
 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]);
 142
 143         byte[] data2 = { 2, 8 };
 144         bits = BitBufferHelper.getBits(data2, 0, 7); //Short
 145         Assert.assertEquals(1, bits[0]);
 146
 147         bits = BitBufferHelper.getBits(data2, 7, 9); //Short
 148         Assert.assertEquals(0, bits[0]);
 149         Assert.assertEquals(8, bits[1]);
 150     }
 151
 152     // [01101100][01100000]
 153     //     [01100011]
 154     @Test
 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 };
 157
 158         Assert.assertEquals(108, BitBufferHelper.getBits(data, 0, 8)[0]);
 159         Assert.assertEquals(96, BitBufferHelper.getBits(data, 8, 8)[0]);
 160
 161         byte[]  bits = BitBufferHelper.getBits(data, 0, 10);
 162         Assert.assertEquals(1, bits[0]);
 163         Assert.assertEquals(bits[1], -79);
 164
 165         bits = BitBufferHelper.getBits(data, 3, 8);
 166         Assert.assertEquals(99, bits[0]);
 167         //Assert.assertTrue(x[1] == 97);
 168
 169     }
 170
 171     @Test
 172     public void testMSBMask() {
 173         int numBits = 1; //MSB
 174         int mask = BitBufferHelper.getMSBMask(numBits);
 175         Assert.assertEquals(128, mask);
 176
 177         numBits = 8;
 178         mask = BitBufferHelper.getMSBMask(numBits);
 179         Assert.assertEquals(255, mask);
 180
 181         numBits = 2;
 182         mask = BitBufferHelper.getMSBMask(numBits);
 183         Assert.assertEquals(192, mask);
 184     }
 185
 186     @Test
 187     public void testLSBMask() {
 188         int numBits = 1; //LSB
 189         int mask = BitBufferHelper.getLSBMask(numBits);
 190         Assert.assertEquals(1, mask);
 191
 192         numBits = 3;
 193         mask = BitBufferHelper.getLSBMask(numBits);
 194         Assert.assertEquals(7, mask);
 195
 196         numBits = 8;
 197         mask = BitBufferHelper.getLSBMask(numBits);
 198         Assert.assertEquals(255, mask);
 199     }
 200
 201     @Test
 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);
 207
 208         short sh2 = Short.MIN_VALUE;
 209         byte[] dataShort2 = BitBufferHelper.toByteArray(sh2);
 210         Assert.assertEquals(dataShort2[0], -128);
 211         Assert.assertEquals(0, dataShort2[1]);
 212
 213         short sh3 = 16384;
 214         byte[] dataShort3 = BitBufferHelper.toByteArray(sh3);
 215         Assert.assertEquals(64, dataShort3[0]);
 216         Assert.assertEquals(0, dataShort3[1]);
 217
 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);
 222
 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);
 227
 228         short sh6 = 5312; //numEndRestBits < numBitstoShiftBy
 229         byte[] dataShort6 = BitBufferHelper.toByteArray(sh6);
 230         Assert.assertEquals(20, dataShort6[0]);
 231         Assert.assertEquals(dataShort6[1], -64);
 232
 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);
 239
 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]);
 246
 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]);
 253
 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);
 264
 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]);
 275
 276         byte byte1 = Byte.MAX_VALUE;
 277         byte[] dataByte1 = BitBufferHelper.toByteArray(byte1);
 278         Assert.assertEquals(127, dataByte1[0]);
 279
 280         byte byte2 = Byte.MIN_VALUE;
 281         byte[] dataByte2 = BitBufferHelper.toByteArray(byte2);
 282         Assert.assertEquals(dataByte2[0], -128);
 283
 284         byte byte3 = 64;
 285         byte[] dataByte3 = BitBufferHelper.toByteArray(byte3);
 286         Assert.assertEquals(64, dataByte3[0]);
 287
 288         byte byte4 = 32;
 289         byte[] dataByte4 = BitBufferHelper.toByteArray(byte4);
 290         Assert.assertEquals(32, dataByte4[0]);
 291
 292     }
 293
 294     @Test
 295     public void testToByteArrayVariable() {
 296         int len = 9;
 297         byte[] dataShort;
 298         dataShort = BitBufferHelper.toByteArray(511, len);
 299         Assert.assertEquals(dataShort[0], (byte) 255);
 300         Assert.assertEquals(dataShort[1], (byte) 128);
 301
 302         dataShort = BitBufferHelper.toByteArray(511, len);
 303         Assert.assertEquals(dataShort[0], (byte) 255);
 304         Assert.assertEquals(dataShort[1], (byte) 128);
 305
 306         dataShort = BitBufferHelper.toByteArray((long) 511, len);
 307         Assert.assertEquals(dataShort[0], (byte) 255);
 308         Assert.assertEquals(dataShort[1], (byte) 128);
 309     }
 310
 311     @Test
 312     public void testToInt() {
 313         byte[] data = { 1 };
 314         Assert.assertEquals(1, BitBufferHelper.toNumber(data));
 315
 316         byte[] data2 = { 1, 1 };
 317         Assert.assertEquals(257, BitBufferHelper.toNumber(data2));
 318
 319         byte[] data3 = { 1, 1, 1 };
 320         Assert.assertEquals(65793, BitBufferHelper.toNumber(data3));
 321     }
 322
 323     @Test
 324     public void testToLongGetter() {
 325         byte[] data = { 1, 1 };
 326         Assert.assertEquals(257L, BitBufferHelper.getLong(data));
 327     }
 328
 329     @Test
 330     public void testSetByte() throws Exception {
 331         byte input;
 332         byte[] data = new byte[20];
 333
 334         input = 125;
 335         BitBufferHelper.setByte(data, input, 0, Byte.SIZE);
 336         Assert.assertEquals(125, data[0]);
 337
 338         input = 109;
 339         BitBufferHelper.setByte(data, input, 152, Byte.SIZE);
 340         Assert.assertEquals(109, data[19]);
 341     }
 342
 343     @Test
 344     public void testSetBytes() throws Exception {
 345         byte[] input = { 0, 1 };
 346         byte[] data = { 6, 0 };
 347
 348         BitBufferHelper.setBytes(data, input, 7, 9);
 349         Assert.assertEquals(6, data[0]);
 350         Assert.assertEquals(1, data[1]);
 351     }
 352
 353     @Test
 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 };
 360         int startOffset;
 361         int numBits;
 362
 363         byte[] data1 = new byte[2];
 364         startOffset = 0;
 365         numBits = 16;
 366         BitBufferHelper.insertBits(data1, inputdata, startOffset, numBits);
 367         Assert.assertEquals(75, data1[0]);
 368         Assert.assertEquals(110, data1[1]);
 369
 370         byte[] data2 = new byte[4];
 371         startOffset = 0;
 372         numBits = 32;
 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]);
 378
 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];
 383         startOffset = 0;
 384         numBits = 13;
 385         BitBufferHelper.insertBits(data10, inputdata, startOffset, numBits);
 386         Assert.assertEquals(75, data10[0]);
 387         Assert.assertEquals(104, data10[1]);
 388
 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];
 393         startOffset = 8;
 394         numBits = 6;
 395         BitBufferHelper.insertBits(data11, inputdata, startOffset, numBits);
 396         Assert.assertEquals(72, data11[1]);
 397
 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];
 402         startOffset = 0;
 403         numBits = 23;
 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]);
 408
 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];
 413         startOffset = 8;
 414         numBits = 20;
 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]);
 419
 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];
 424         startOffset = 0;
 425         numBits = 30;
 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]);
 431
 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];
 437         startOffset = 3;
 438         numBits = 8;
 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]);
 443
 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}
 448
 449         startOffset = 3;
 450         numBits = 16;
 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]);
 457
 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 };
 463         startOffset = 3;
 464         numBits = 16;
 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);
 469
 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}
 474
 475         startOffset = 3;
 476         numBits = 32;
 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]);
 484
 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}
 489         startOffset = 33;
 490         numBits = 16;
 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]);
 496
 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}
 502         startOffset = 3;
 503         numBits = 7;
 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]);
 509
 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}
 514         startOffset = 5;
 515         numBits = 17;
 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]);
 521
 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}
 526         startOffset = 3;
 527         numBits = 23;
 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]);
 534
 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}
 539         startOffset = 3;
 540         numBits = 13;
 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]);
 546
 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}
 551         startOffset = 4;
 552         numBits = 20;
 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);
 559
 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}
 564         startOffset = 13;
 565         numBits = 11;
 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]);
 572
 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}
 577         startOffset = 3;
 578         numBits = 17;
 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]);
 585
 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}
 591         startOffset = 18;
 592         numBits = 34;
 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]);
 602
 603     }
 604
 605     @Test
 606     public void testGetShort() {
 607         byte[] data = new byte[2];
 608         data[0] = 7;
 609         data[1] = 8;
 610         int length = 9; // num bits
 611         Assert.assertEquals(264, BitBufferHelper.getShort(data, length));
 612
 613         data[0] = 6;
 614         data[1] = 8;
 615         short result = BitBufferHelper.getShort(data, length);
 616         Assert.assertEquals(8, result);
 617
 618         data[0] = 8;
 619         data[1] = 47;
 620         result = BitBufferHelper.getShort(data, length);
 621         Assert.assertEquals(47, result);
 622
 623         //[0000 0001] [0001 0100] [0110 0100]
 624         byte[] data1 = new byte[2];
 625         data1[0] = 1;
 626         data1[1] = 20; //data1[2] = 100;
 627         length = 15;
 628         result = BitBufferHelper.getShort(data1, length);
 629         Assert.assertEquals(276, result);
 630
 631         byte[] data2 = new byte[2];
 632         data2[0] = 64;
 633         data2[1] = 99; //data2[2] = 100;
 634         length = 13;
 635         result = BitBufferHelper.getShort(data2, length);
 636         Assert.assertEquals(99, result);
 637
 638         byte[] data3 = { 100, 50 };
 639         result = BitBufferHelper.getShort(data3);
 640         Assert.assertEquals(25650, result);
 641     }
 642
 643     @Test
 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));
 648
 649         byte[] data2 = { 0, 8 };
 650         Assert.assertEquals(8, BitBufferHelper.getInt(data2, 9));
 651
 652         byte[] data3 = { 1, 1, 1 };
 653         Assert.assertEquals(65793, BitBufferHelper.getInt(data3));
 654
 655         byte[] data4 = { 1, 1, 1 };
 656         Assert.assertEquals(65793, BitBufferHelper.getInt(data4));
 657
 658         byte[] data5 = { 1, 1 };
 659         Assert.assertEquals(257, BitBufferHelper.getInt(data5));
 660
 661     }
 662
 663     @Test
 664     public void testShiftBitstoLSB() {
 665         byte[] data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
 666
 667         byte[] data2 = { 8, 9, 10 };
 668         byte[] shiftedBytes2 = BitBufferHelper.shiftBitsToLSB(data2, 11);
 669
 670         Assert.assertEquals(0, shiftedBytes2[0]);
 671         Assert.assertEquals(64, shiftedBytes2[1]);
 672         Assert.assertEquals(72, shiftedBytes2[2]);
 673
 674         byte[] shiftedBytes = BitBufferHelper.shiftBitsToLSB(data, 49);
 675
 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]);
 686
 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]);
 692
 693     }
 694
 695     @Test
 696     public void testShiftBitsToLSBAndMSB() {
 697         byte[] data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
 698
 699         byte[] clone = BitBufferHelper.shiftBitsToMSB(BitBufferHelper
 700                 .shiftBitsToLSB(data, 72), 72);
 701
 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]);
 712     }
 713
 714 }