07fbf0599b889d6281e4f7e0b1819912969ea711
[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 junit.framework.Assert;
13
14 import org.junit.Test;
15 import org.opendaylight.controller.liblldp.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 }

©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.