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