Update junit Assert imports
[controller.git] / opendaylight / commons / liblldp / 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 import org.junit.Test;
14 import org.opendaylight.controller.liblldp.BitBufferHelper;
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 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.