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.Test;
  13
  14 public class BitBufferHelperTest {
  15     @Test
  16     public void testToNumberNominal() {
  17         byte[] array = new byte[] { -1, -1, -1, -1 };
  18         long expected = 0;
  19         for (int i = 0; i < 32; i++) {
  20             Assert.assertEquals(expected, BitBufferHelper.toNumber(array, i));
  21             expected += 1 << i;
  22         }
  23     }
  24
  25     @Test
  26     public void testToNumberWithSmallArray() {
  27         byte[] array = new byte[] { -1 };
  28         long expected = 0;
  29         for (int i = 0; i < 32; i++) {
  30             Assert.assertEquals(expected, BitBufferHelper.toNumber(array, i));
  31             if (i < 8) {
  32                 expected += 1 << i;
  33             }
  34         }
  35     }
  36
  37     @Test
  38     public void testGetByte() {
  39         byte[] data = { 100 };
  40         Assert.assertEquals(100, BitBufferHelper.getByte(data));
  41     }
  42
  43     @Test
  44     public void testGetBits() throws Exception {
  45         byte[] data = { 10, 12, 14, 20, 55, 69, 82, 97, 109, 117, 127, -50 };
  46         byte[] bits;
  47
  48         bits = BitBufferHelper.getBits(data, 88, 8); //BYTE extraOffsetBits = extranumBits = 0
  49         Assert.assertEquals(bits[0], -50);
  50
  51         bits = BitBufferHelper.getBits(data, 8, 16); //Short
  52         Assert.assertEquals(12, bits[0]);
  53         Assert.assertEquals(14, bits[1]);
  54
  55         bits = BitBufferHelper.getBits(data, 32, 32); //Int
  56         Assert.assertEquals(55, bits[0]);
  57         Assert.assertEquals(69, bits[1]);
  58         Assert.assertEquals(82, bits[2]);
  59         Assert.assertEquals(97, bits[3]);
  60
  61         bits = BitBufferHelper.getBits(data, 16, 48); //Long
  62         Assert.assertEquals(14, bits[0]);
  63         Assert.assertEquals(20, bits[1]);
  64         Assert.assertEquals(55, bits[2]);
  65         Assert.assertEquals(69, bits[3]);
  66         Assert.assertEquals(82, bits[4]);
  67         Assert.assertEquals(97, bits[5]);
  68
  69         bits = BitBufferHelper.getBits(data, 40, 7); //BYTE extraOffsetBits = extranumBits != 0
  70         Assert.assertEquals(34, bits[0]);
  71
  72         bits = BitBufferHelper.getBits(data, 8, 13); //Short
  73         Assert.assertEquals(1, bits[0]);
  74         Assert.assertEquals(bits[1], -127);
  75
  76         bits = BitBufferHelper.getBits(data, 32, 28); //Int
  77         Assert.assertEquals(3, bits[0]);
  78         Assert.assertEquals(116, bits[1]);
  79         Assert.assertEquals(85, bits[2]);
  80         Assert.assertEquals(38, bits[3]);
  81
  82         bits = BitBufferHelper.getBits(data, 16, 41); //Long
  83         Assert.assertEquals(0, bits[0]);
  84         Assert.assertEquals(28, bits[1]);
  85         Assert.assertEquals(40, bits[2]);
  86         Assert.assertEquals(110, bits[3]);
  87         Assert.assertEquals(bits[4], -118);
  88         Assert.assertEquals(bits[5], -92);
  89
  90         bits = BitBufferHelper.getBits(data, 3, 7); //BYTE extraOffsetBits != 0; extranumBits == 0
  91         Assert.assertEquals(40, bits[0]);
  92
  93         bits = BitBufferHelper.getBits(data, 13, 16); //Short
  94         Assert.assertEquals(bits[0], -127);
  95         Assert.assertEquals(bits[1], -62);
  96
  97         bits = BitBufferHelper.getBits(data, 5, 32); //Int
  98         Assert.assertEquals(65, bits[0]);
  99         Assert.assertEquals(bits[1], -127);
 100         Assert.assertEquals(bits[2], -62);
 101         Assert.assertEquals(bits[3], -122);
 102
 103         bits = BitBufferHelper.getBits(data, 23, 48); //Long
 104         Assert.assertEquals(10, bits[0]);
 105         Assert.assertEquals(27, bits[1]);
 106         Assert.assertEquals(bits[2], -94);
 107         Assert.assertEquals(bits[3], -87);
 108         Assert.assertEquals(48, bits[4]);
 109         Assert.assertEquals(bits[5], -74);
 110
 111         bits = BitBufferHelper.getBits(data, 66, 9); //BYTE extraOffsetBits != 0; extranumBits != 0
 112         Assert.assertEquals(1, bits[0]);
 113         Assert.assertEquals(107, bits[1]);
 114
 115         bits = BitBufferHelper.getBits(data, 13, 15); //Short
 116         Assert.assertEquals(64, bits[0]);
 117         Assert.assertEquals(bits[1], -31);
 118
 119         bits = BitBufferHelper.getBits(data, 5, 29); //Int
 120         Assert.assertEquals(8, bits[0]);
 121         Assert.assertEquals(48, bits[1]);
 122         Assert.assertEquals(56, bits[2]);
 123         Assert.assertEquals(80, bits[3]);
 124
 125         bits = BitBufferHelper.getBits(data, 31, 43); //Long
 126         Assert.assertEquals(0, bits[0]);
 127         Assert.assertEquals(bits[1], -35);
 128         Assert.assertEquals(21, bits[2]);
 129         Assert.assertEquals(73, bits[3]);
 130         Assert.assertEquals(bits[4], -123);
 131         Assert.assertEquals(bits[5], -75);
 132
 133         bits = BitBufferHelper.getBits(data, 4, 12); //Short
 134         Assert.assertEquals(10, bits[0]);
 135         Assert.assertEquals(12, bits[1]);
 136
 137         byte[] data1 = { 0, 8 };
 138         bits = BitBufferHelper.getBits(data1, 7, 9); //Short
 139         Assert.assertEquals(0, bits[0]);
 140         Assert.assertEquals(8, bits[1]);
 141
 142         byte[] data2 = { 2, 8 };
 143         bits = BitBufferHelper.getBits(data2, 0, 7); //Short
 144         Assert.assertEquals(1, bits[0]);
 145
 146         bits = BitBufferHelper.getBits(data2, 7, 9); //Short
 147         Assert.assertEquals(0, bits[0]);
 148         Assert.assertEquals(8, bits[1]);
 149     }
 150
 151     // [01101100][01100000]
 152     //     [01100011]
 153     @Test
 154     public void testGetBytes() throws Exception {
 155         byte[] data = { 108, 96, 125, -112, 5, 6, 108, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22 };
 156
 157         Assert.assertEquals(108, BitBufferHelper.getBits(data, 0, 8)[0]);
 158         Assert.assertEquals(96, BitBufferHelper.getBits(data, 8, 8)[0]);
 159
 160         byte[]  bits = BitBufferHelper.getBits(data, 0, 10);
 161         Assert.assertEquals(1, bits[0]);
 162         Assert.assertEquals(bits[1], -79);
 163
 164         bits = BitBufferHelper.getBits(data, 3, 8);
 165         Assert.assertEquals(99, bits[0]);
 166         //Assert.assertTrue(x[1] == 97);
 167
 168     }
 169
 170     @Test
 171     public void testMSBMask() {
 172         int numBits = 1; //MSB
 173         int mask = BitBufferHelper.getMSBMask(numBits);
 174         Assert.assertEquals(128, mask);
 175
 176         numBits = 8;
 177         mask = BitBufferHelper.getMSBMask(numBits);
 178         Assert.assertEquals(255, mask);
 179
 180         numBits = 2;
 181         mask = BitBufferHelper.getMSBMask(numBits);
 182         Assert.assertEquals(192, mask);
 183     }
 184
 185     @Test
 186     public void testLSBMask() {
 187         int numBits = 1; //LSB
 188         int mask = BitBufferHelper.getLSBMask(numBits);
 189         Assert.assertEquals(1, mask);
 190
 191         numBits = 3;
 192         mask = BitBufferHelper.getLSBMask(numBits);
 193         Assert.assertEquals(7, mask);
 194
 195         numBits = 8;
 196         mask = BitBufferHelper.getLSBMask(numBits);
 197         Assert.assertEquals(255, mask);
 198     }
 199
 200     @Test
 201     public void testToByteArray() {
 202         short sh = Short.MAX_VALUE;
 203         byte[] dataShort = BitBufferHelper.toByteArray(sh);
 204         Assert.assertEquals(127, dataShort[0]);
 205         Assert.assertEquals(dataShort[1], -1);
 206
 207         short sh2 = Short.MIN_VALUE;
 208         byte[] dataShort2 = BitBufferHelper.toByteArray(sh2);
 209         Assert.assertEquals(dataShort2[0], -128);
 210         Assert.assertEquals(0, dataShort2[1]);
 211
 212         short sh3 = 16384;
 213         byte[] dataShort3 = BitBufferHelper.toByteArray(sh3);
 214         Assert.assertEquals(64, dataShort3[0]);
 215         Assert.assertEquals(0, dataShort3[1]);
 216
 217         short sh4 = 146; //TCP headerlenflags - startoffset = 103
 218         byte[] dataShort4 = BitBufferHelper.toByteArray(sh4);
 219         Assert.assertEquals(0, dataShort4[0]);
 220         Assert.assertEquals(dataShort4[1], -110);
 221
 222         short sh5 = 5000; //IPv4 Offset - startOffset = 51 (to 63)
 223         byte[] dataShort5 = BitBufferHelper.toByteArray(sh5);
 224         Assert.assertEquals(19, dataShort5[0]);
 225         Assert.assertEquals(dataShort5[1], -120);
 226
 227         short sh6 = 5312; //numEndRestBits < numBitstoShiftBy
 228         byte[] dataShort6 = BitBufferHelper.toByteArray(sh6);
 229         Assert.assertEquals(20, dataShort6[0]);
 230         Assert.assertEquals(dataShort6[1], -64);
 231
 232         int int1 = Integer.MAX_VALUE;
 233         byte[] dataInt1 = BitBufferHelper.toByteArray(int1);
 234         Assert.assertEquals(127, dataInt1[0]);
 235         Assert.assertEquals(dataInt1[1], -1);
 236         Assert.assertEquals(dataInt1[2], -1);
 237         Assert.assertEquals(dataInt1[3], -1);
 238
 239         int int2 = Integer.MIN_VALUE;
 240         byte[] dataInt2 = BitBufferHelper.toByteArray(int2);
 241         Assert.assertEquals(dataInt2[0], -128);
 242         Assert.assertEquals(0, dataInt2[1]);
 243         Assert.assertEquals(0, dataInt2[2]);
 244         Assert.assertEquals(0, dataInt2[3]);
 245
 246         int int3 = 1077952576;
 247         byte[] dataInt3 = BitBufferHelper.toByteArray(int3);
 248         Assert.assertEquals(64, dataInt3[0]);
 249         Assert.assertEquals(64, dataInt3[1]);
 250         Assert.assertEquals(64, dataInt3[2]);
 251         Assert.assertEquals(64, dataInt3[3]);
 252
 253         long long1 = Long.MAX_VALUE;
 254         byte[] dataLong1 = BitBufferHelper.toByteArray(long1);
 255         Assert.assertEquals(127, dataLong1[0]);
 256         Assert.assertEquals(dataLong1[1], -1);
 257         Assert.assertEquals(dataLong1[2], -1);
 258         Assert.assertEquals(dataLong1[3], -1);
 259         Assert.assertEquals(dataLong1[4], -1);
 260         Assert.assertEquals(dataLong1[5], -1);
 261         Assert.assertEquals(dataLong1[6], -1);
 262         Assert.assertEquals(dataLong1[7], -1);
 263
 264         long long2 = Long.MIN_VALUE;
 265         byte[] dataLong2 = BitBufferHelper.toByteArray(long2);
 266         Assert.assertEquals(dataLong2[0], -128);
 267         Assert.assertEquals(0, dataLong2[1]);
 268         Assert.assertEquals(0, dataLong2[2]);
 269         Assert.assertEquals(0, dataLong2[3]);
 270         Assert.assertEquals(0, dataLong2[4]);
 271         Assert.assertEquals(0, dataLong2[5]);
 272         Assert.assertEquals(0, dataLong2[6]);
 273         Assert.assertEquals(0, dataLong2[7]);
 274
 275         byte byte1 = Byte.MAX_VALUE;
 276         byte[] dataByte1 = BitBufferHelper.toByteArray(byte1);
 277         Assert.assertEquals(127, dataByte1[0]);
 278
 279         byte byte2 = Byte.MIN_VALUE;
 280         byte[] dataByte2 = BitBufferHelper.toByteArray(byte2);
 281         Assert.assertEquals(dataByte2[0], -128);
 282
 283         byte byte3 = 64;
 284         byte[] dataByte3 = BitBufferHelper.toByteArray(byte3);
 285         Assert.assertEquals(64, dataByte3[0]);
 286
 287         byte byte4 = 32;
 288         byte[] dataByte4 = BitBufferHelper.toByteArray(byte4);
 289         Assert.assertEquals(32, dataByte4[0]);
 290
 291     }
 292
 293     @Test
 294     public void testToByteArrayVariable() {
 295         int len = 9;
 296         byte[] dataShort;
 297         dataShort = BitBufferHelper.toByteArray(511, len);
 298         Assert.assertEquals(dataShort[0], (byte) 255);
 299         Assert.assertEquals(dataShort[1], (byte) 128);
 300
 301         dataShort = BitBufferHelper.toByteArray(511, len);
 302         Assert.assertEquals(dataShort[0], (byte) 255);
 303         Assert.assertEquals(dataShort[1], (byte) 128);
 304
 305         dataShort = BitBufferHelper.toByteArray((long) 511, len);
 306         Assert.assertEquals(dataShort[0], (byte) 255);
 307         Assert.assertEquals(dataShort[1], (byte) 128);
 308     }
 309
 310     @Test
 311     public void testToInt() {
 312         byte[] data = { 1 };
 313         Assert.assertEquals(1, BitBufferHelper.toNumber(data));
 314
 315         byte[] data2 = { 1, 1 };
 316         Assert.assertEquals(257, BitBufferHelper.toNumber(data2));
 317
 318         byte[] data3 = { 1, 1, 1 };
 319         Assert.assertEquals(65793, BitBufferHelper.toNumber(data3));
 320     }
 321
 322     @Test
 323     public void testToLongGetter() {
 324         byte[] data = { 1, 1 };
 325         Assert.assertEquals(257L, BitBufferHelper.getLong(data));
 326     }
 327
 328     @Test
 329     public void testSetByte() throws Exception {
 330         byte input;
 331         byte[] data = new byte[20];
 332
 333         input = 125;
 334         BitBufferHelper.setByte(data, input, 0);
 335         Assert.assertEquals(125, data[0]);
 336
 337         input = 109;
 338         BitBufferHelper.setByte(data, input, 152);
 339         Assert.assertEquals(109, data[19]);
 340     }
 341
 342     @Test
 343     public void testCopyBitsFromLsb() throws Exception {
 344         byte[] input = { 0, 1 }; // 00000000 00000001
 345         byte[] data = { 6, 0 };  // 00000110 00000000
 346
 347         BitBufferHelper.copyBitsFromLsb(data, input, 7, 9);
 348         // Expecting 00000110 000000001
 349         Assert.assertEquals(6, data[0]);
 350         Assert.assertEquals(1, data[1]);
 351     }
 352
 353     @Test
 354     //INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
 355     // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]*/
 356     public void testCopyBitsFromMsb() throws BufferException {
 357         //CASE 1: startOffset%8 == 0 && numBits%8 == 0
 358         byte[] inputdata = { 75, 110, 107, 80, 10, 12, 35, 100, 125, 65 };
 359         int startOffset;
 360         int numBits;
 361
 362         byte[] data1 = new byte[2];
 363         startOffset = 0;
 364         numBits = 16;
 365         BitBufferHelper.copyBitsFromMsb(data1, inputdata, startOffset, numBits);
 366         Assert.assertEquals(75, data1[0]);
 367         Assert.assertEquals(110, data1[1]);
 368
 369         byte[] data2 = new byte[4];
 370         startOffset = 0;
 371         numBits = 32;
 372         BitBufferHelper.copyBitsFromMsb(data2, inputdata, startOffset, numBits);
 373         Assert.assertEquals(75, data2[0]);
 374         Assert.assertEquals(110, data2[1]);
 375         Assert.assertEquals(107, data2[2]);
 376         Assert.assertEquals(80, data2[3]);
 377
 378         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
 379         // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
 380         // OUTPUT: [01001011] [01101000] = {75, 104}
 381         byte[] data10 = new byte[2];
 382         startOffset = 0;
 383         numBits = 13;
 384         BitBufferHelper.copyBitsFromMsb(data10, inputdata, startOffset, numBits);
 385         Assert.assertEquals(75, data10[0]);
 386         Assert.assertEquals(104, data10[1]);
 387
 388         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
 389         // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
 390         // OUTPUT: [01001000] = {72}
 391         byte[] data11 = new byte[4];
 392         startOffset = 8;
 393         numBits = 6;
 394         BitBufferHelper.copyBitsFromMsb(data11, inputdata, startOffset, numBits);
 395         Assert.assertEquals(72, data11[1]);
 396
 397         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
 398         // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
 399         // OUTPUT: [01001011] [01101110] [01101000] = {75, 110, 105}
 400         byte[] data12 = new byte[4];
 401         startOffset = 0;
 402         numBits = 23;
 403         BitBufferHelper.copyBitsFromMsb(data12, inputdata, startOffset, numBits);
 404         Assert.assertEquals(75, data12[0]);
 405         Assert.assertEquals(110, data12[1]);
 406         Assert.assertEquals(106, data12[2]);
 407
 408         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
 409         // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
 410         // OUTPUT: [01001011] [01101110] [01100000] = {75, 110, 96}
 411         byte[] data13 = new byte[4];
 412         startOffset = 8;
 413         numBits = 20;
 414         BitBufferHelper.copyBitsFromMsb(data13, inputdata, startOffset, numBits);
 415         Assert.assertEquals(75, data13[1]);
 416         Assert.assertEquals(110, data13[2]);
 417         Assert.assertEquals(96, data13[3]);
 418
 419         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
 420         // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
 421         // OUTPUT: [01001011] [01101110] [01101011] [10100000]= {75, 110, 107, 80}
 422         byte[] data14 = new byte[4];
 423         startOffset = 0;
 424         numBits = 30;
 425         BitBufferHelper.copyBitsFromMsb(data14, inputdata, startOffset, numBits);
 426         Assert.assertEquals(75, data14[0]);
 427         Assert.assertEquals(110, data14[1]);
 428         Assert.assertEquals(107, data14[2]);
 429         Assert.assertEquals(80, data14[3]);
 430
 431         //CASE 3: startOffset%8 != 0, numBits%8 = 0
 432         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
 433         // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
 434         // OUTPUT: [00001001] [11000000] = {72, 96}
 435         byte[] data16 = new byte[5];
 436         startOffset = 3;
 437         numBits = 8;
 438         BitBufferHelper.copyBitsFromMsb(data16, inputdata, startOffset, numBits);
 439         Assert.assertEquals(9, data16[0]);
 440         Assert.assertEquals(96, data16[1]);
 441         Assert.assertEquals(0, data16[2]);
 442
 443         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
 444         // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
 445         // OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
 446         // OUTPUT: [00000100] [1011 0110] [1110 0000] = {4, -54, -96}
 447
 448         startOffset = 3;
 449         numBits = 16;
 450         byte[] data17 = new byte[5];
 451         BitBufferHelper.copyBitsFromMsb(data17, inputdata, startOffset, numBits);
 452         Assert.assertEquals(9, data17[0]);
 453         Assert.assertEquals(109, data17[1]);
 454         Assert.assertEquals(data17[2], -64);
 455         Assert.assertEquals(0, data17[3]);
 456
 457         // INPUT: {79, 110, 111}
 458         // = [01001111] [01101110] [01101111]
 459         //OUTPUT: [0000 1001] [1110 1101] [110 00000] = {9, -19, -64}
 460         byte[] data18 = new byte[5];
 461         byte[] inputdata3 = { 79, 110, 111 };
 462         startOffset = 3;
 463         numBits = 16;
 464         BitBufferHelper.copyBitsFromMsb(data18, inputdata3, startOffset, numBits);
 465         Assert.assertEquals(9, data18[0]);
 466         Assert.assertEquals(data18[1], -19);
 467         Assert.assertEquals(data18[2], -64);
 468
 469         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
 470         // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
 471         // OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
 472         // OUTPUT: [0000 1001] [0110 1101] [1100 1101] [0110 1010] [0000 0001] = {9, 109, -51, 106, 0}
 473
 474         startOffset = 3;
 475         numBits = 32;
 476         byte[] data19 = new byte[5];
 477         BitBufferHelper.copyBitsFromMsb(data19, inputdata, startOffset, numBits);
 478         Assert.assertEquals(9, data19[0]);
 479         Assert.assertEquals(109, data19[1]);
 480         Assert.assertEquals(data19[2], -51);
 481         Assert.assertEquals(106, data19[3]);
 482         Assert.assertEquals(0, data19[4]);
 483
 484         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
 485         // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
 486         // OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
 487         // OUTPUT: data[4, 5, 6] = [0 010 0101] [1 011 0111] [0 000 0000] = {37, -73, 0}
 488         startOffset = 33;
 489         numBits = 16;
 490         byte[] data20 = new byte[7];
 491         BitBufferHelper.copyBitsFromMsb(data20, inputdata, startOffset, numBits);
 492         Assert.assertEquals(37, data20[4]);
 493         Assert.assertEquals(data20[5], -73);
 494         Assert.assertEquals(0, data20[6]);
 495
 496         //CASE 4: extranumBits != 0 AND extraOffsetBits != 0
 497         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
 498         // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
 499         // OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
 500         // OUTPUT: [0000 1001] [0100 0000]  = {9, 96}
 501         startOffset = 3;
 502         numBits = 7;
 503         byte[] data21 = new byte[7];
 504         BitBufferHelper.copyBitsFromMsb(data21, inputdata, startOffset, numBits);
 505         Assert.assertEquals(9, data21[0]);
 506         Assert.assertEquals(64, data21[1]);
 507         Assert.assertEquals(0, data21[2]);
 508
 509         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
 510         // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
 511         // OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
 512         // OUTPUT: data = [00000 010] [01011 011] [01110 000] = {37, -73, 0}
 513         startOffset = 5;
 514         numBits = 17;
 515         byte[] data22 = new byte[7];
 516         BitBufferHelper.copyBitsFromMsb(data22, inputdata, startOffset, numBits);
 517         Assert.assertEquals(2, data22[0]);
 518         Assert.assertEquals(91, data22[1]);
 519         Assert.assertEquals(112, data22[2]);
 520
 521         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
 522         // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
 523         // OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
 524         // OUTPUT: [0000 1001] [0110 1101] [110 01101] [01 00000] = {9, 109, -51, 64}
 525         startOffset = 3;
 526         numBits = 23;
 527         byte[] data23 = new byte[7];
 528         BitBufferHelper.copyBitsFromMsb(data23, inputdata, startOffset, numBits);
 529         Assert.assertEquals(9, data23[0]);
 530         Assert.assertEquals(109, data23[1]);
 531         Assert.assertEquals(data23[2], -51);
 532         Assert.assertEquals(64, data23[3]);
 533
 534         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
 535         // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
 536         // OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
 537         // OUTPUT: [0000 1001] [0110 1101]  = {9, 109}
 538         startOffset = 3;
 539         numBits = 13;
 540         byte[] data24 = new byte[7];
 541         BitBufferHelper.copyBitsFromMsb(data24, inputdata, startOffset, numBits);
 542         Assert.assertEquals(9, data24[0]);
 543         Assert.assertEquals(109, data24[1]);
 544         Assert.assertEquals(0, data24[2]);
 545
 546         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
 547         // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
 548         // OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
 549         // OUTPUT: [0000 0100] [1011 0110] [1110 0110]  = {4, -74, -26}
 550         startOffset = 4;
 551         numBits = 20;
 552         byte[] data25 = new byte[7];
 553         BitBufferHelper.copyBitsFromMsb(data25, inputdata, startOffset, numBits);
 554         Assert.assertEquals(4, data25[0]);
 555         Assert.assertEquals(data25[1], -74);
 556         Assert.assertEquals(data25[2], -26);
 557         Assert.assertEquals(data25[3], -0);
 558
 559         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
 560         // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
 561         // OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
 562         // OUTPUT: [0000 0010] [0101 1011]   = {0, 2, 91, 0}
 563         startOffset = 13;
 564         numBits = 11;
 565         byte[] data26 = new byte[7];
 566         BitBufferHelper.copyBitsFromMsb(data26, inputdata, startOffset, numBits);
 567         Assert.assertEquals(0, data26[0]);
 568         Assert.assertEquals(2, data26[1]);
 569         Assert.assertEquals(91, data26[2]);
 570         Assert.assertEquals(0, data26[3]);
 571
 572         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
 573         // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
 574         // OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
 575         // OUTPUT: [000 01001] [011 01101] [110 0 0000]   = {9, 109, -64, 0}
 576         startOffset = 3;
 577         numBits = 17;
 578         byte[] data27 = new byte[7];
 579         BitBufferHelper.copyBitsFromMsb(data27, inputdata, startOffset, numBits);
 580         Assert.assertEquals(9, data27[0]);
 581         Assert.assertEquals(109, data27[1]);
 582         Assert.assertEquals(data27[2], -64);
 583         Assert.assertEquals(0, data27[3]);
 584
 585         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
 586         // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]
 587         // OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
 588         // OUTPUT: [00 000000] [00 000000] [00 010010] [11 011011] [10 011010] [11 010100] [0000 0000] =
 589         //    {0, 0, 18, -37,-102,-44,0}
 590         startOffset = 18;
 591         numBits = 34;
 592         byte[] data28 = new byte[7];
 593         BitBufferHelper.copyBitsFromMsb(data28, inputdata, startOffset, numBits);
 594         Assert.assertEquals(0, data28[0]);
 595         Assert.assertEquals(0, data28[1]);
 596         Assert.assertEquals(18, data28[2]);
 597         Assert.assertEquals(data28[3], -37);
 598         Assert.assertEquals(data28[4], -102);
 599         Assert.assertEquals(data28[5], -44);
 600         Assert.assertEquals(0, data28[6]);
 601     }
 602
 603     @Test
 604     public void testGetShort() {
 605         byte[] data = new byte[2];
 606         data[0] = 7;
 607         data[1] = 8;
 608         int length = 9; // num bits
 609         Assert.assertEquals(264, BitBufferHelper.getShort(data, length));
 610
 611         data[0] = 6;
 612         data[1] = 8;
 613         short result = BitBufferHelper.getShort(data, length);
 614         Assert.assertEquals(8, result);
 615
 616         data[0] = 8;
 617         data[1] = 47;
 618         result = BitBufferHelper.getShort(data, length);
 619         Assert.assertEquals(47, result);
 620
 621         //[0000 0001] [0001 0100] [0110 0100]
 622         byte[] data1 = new byte[2];
 623         data1[0] = 1;
 624         data1[1] = 20; //data1[2] = 100;
 625         length = 15;
 626         result = BitBufferHelper.getShort(data1, length);
 627         Assert.assertEquals(276, result);
 628
 629         byte[] data2 = new byte[2];
 630         data2[0] = 64;
 631         data2[1] = 99; //data2[2] = 100;
 632         length = 13;
 633         result = BitBufferHelper.getShort(data2, length);
 634         Assert.assertEquals(99, result);
 635
 636         byte[] data3 = { 100, 50 };
 637         result = BitBufferHelper.getShort(data3);
 638         Assert.assertEquals(25650, result);
 639     }
 640
 641     @Test
 642     public void testToIntVarLength() {
 643         byte[] data = { (byte) 255, (byte) 128 };
 644         int length = 9; // num bits
 645         Assert.assertEquals(384, BitBufferHelper.getInt(data, length));
 646
 647         byte[] data2 = { 0, 8 };
 648         Assert.assertEquals(8, BitBufferHelper.getInt(data2, 9));
 649
 650         byte[] data3 = { 1, 1, 1 };
 651         Assert.assertEquals(65793, BitBufferHelper.getInt(data3));
 652
 653         byte[] data4 = { 1, 1, 1 };
 654         Assert.assertEquals(65793, BitBufferHelper.getInt(data4));
 655
 656         byte[] data5 = { 1, 1 };
 657         Assert.assertEquals(257, BitBufferHelper.getInt(data5));
 658
 659     }
 660
 661     @Test
 662     public void testShiftBitstoLSB() {
 663         byte[] data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
 664
 665         byte[] data2 = { 8, 9, 10 };
 666         byte[] shiftedBytes2 = BitBufferHelper.shiftBitsToLSB(data2, 11);
 667
 668         Assert.assertEquals(0, shiftedBytes2[0]);
 669         Assert.assertEquals(64, shiftedBytes2[1]);
 670         Assert.assertEquals(72, shiftedBytes2[2]);
 671
 672         byte[] shiftedBytes = BitBufferHelper.shiftBitsToLSB(data, 49);
 673
 674         Assert.assertEquals(0, shiftedBytes[0]);
 675         Assert.assertEquals(2, shiftedBytes[1]);
 676         Assert.assertEquals(4, shiftedBytes[2]);
 677         Assert.assertEquals(6, shiftedBytes[3]);
 678         Assert.assertEquals(8, shiftedBytes[4]);
 679         Assert.assertEquals(10, shiftedBytes[5]);
 680         Assert.assertEquals(12, shiftedBytes[6]);
 681         Assert.assertEquals(14, shiftedBytes[7]);
 682         Assert.assertEquals(16, shiftedBytes[8]);
 683         Assert.assertEquals(18, shiftedBytes[9]);
 684
 685         byte[] data1 = { 1, 2, 3 };
 686         byte[] shiftedBytes1 = BitBufferHelper.shiftBitsToLSB(data1, 18);
 687         Assert.assertEquals(0, shiftedBytes1[0]);
 688         Assert.assertEquals(4, shiftedBytes1[1]);
 689         Assert.assertEquals(8, shiftedBytes1[2]);
 690
 691     }
 692
 693     @Test
 694     public void testShiftBitsToLSBAndMSB() {
 695         byte[] data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
 696
 697         byte[] clone = BitBufferHelper.shiftBitsToMSB(BitBufferHelper
 698                 .shiftBitsToLSB(data, 72), 72);
 699
 700         Assert.assertEquals(1, clone[0]);
 701         Assert.assertEquals(2, clone[1]);
 702         Assert.assertEquals(3, clone[2]);
 703         Assert.assertEquals(4, clone[3]);
 704         Assert.assertEquals(5, clone[4]);
 705         Assert.assertEquals(6, clone[5]);
 706         Assert.assertEquals(7, clone[6]);
 707         Assert.assertEquals(8, clone[7]);
 708         Assert.assertEquals(9, clone[8]);
 709         Assert.assertEquals(0, clone[9]);
 710     }
 711
 712 }