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