opendaylight/sal/api/src/test/java/org/opendaylight/controller/sal/packet/BitBufferHelperTest.java

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