Checkstyle enforcer

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

diff --git a/opendaylight/sal/api/src/test/java/org/opendaylight/controller/sal/packet/BitBufferHelperTest.java b/opendaylight/sal/api/src/test/java/org/opendaylight/controller/sal/packet/BitBufferHelperTest.java
index b1c5e945d69aa8c76e53f2de9f936eac1967bf5c..9f74fcab9e40b93601dd72ee8b0ed2f10a57e6e5 100644 (file)
--- a/opendaylight/sal/api/src/test/java/org/opendaylight/controller/sal/packet/BitBufferHelperTest.java
+++ b/opendaylight/sal/api/src/test/java/org/opendaylight/controller/sal/packet/BitBufferHelperTest.java
@@ -374,7 +374,7 @@ public class BitBufferHelperTest {
         Assert.assertTrue(data2[3] == 80);
 
         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
-        // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]               // OUTPUT: [01001011] [01101000] = {75, 104}
+        // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]        // OUTPUT: [01001011] [01101000] = {75, 104}
         byte data10[] = new byte[2];
         startOffset = 0;
         numBits = 13;
@@ -383,7 +383,7 @@ public class BitBufferHelperTest {
         Assert.assertTrue(data10[1] == 104);
 
         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
-        // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]               // OUTPUT: [01001000] = {72}
+        // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]        // OUTPUT: [01001000] = {72}
         byte data11[] = new byte[4];
         startOffset = 8;
         numBits = 6;
@@ -391,7 +391,7 @@ public class BitBufferHelperTest {
         Assert.assertTrue(data11[1] == 72);
 
         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
-        // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]               //OUTPUT: [01001011] [01101110] [01101000] = {75, 110, 105}
+        // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]        //OUTPUT: [01001011] [01101110] [01101000] = {75, 110, 105}
         byte data12[] = new byte[4];
         startOffset = 0;
         numBits = 23;
@@ -401,7 +401,7 @@ public class BitBufferHelperTest {
         Assert.assertTrue(data12[2] == 106);
 
         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
-        // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]               //OUTPUT: [01001011] [01101110] [01100000] = {75, 110, 96}
+        // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]        //OUTPUT: [01001011] [01101110] [01100000] = {75, 110, 96}
         byte data13[] = new byte[4];
         startOffset = 8;
         numBits = 20;
@@ -411,7 +411,7 @@ public class BitBufferHelperTest {
         Assert.assertTrue(data13[3] == 96);
 
         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
-        // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]               //OUTPUT: [01001011] [01101110] [01101011] [10100000]= {75, 110, 107, 80}
+        // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]        //OUTPUT: [01001011] [01101110] [01101011] [10100000]= {75, 110, 107, 80}
         byte data14[] = new byte[4];
         startOffset = 0;
         numBits = 30;
@@ -423,7 +423,7 @@ public class BitBufferHelperTest {
 
         //CASE 3: startOffset%8 != 0, numBits%8 = 0
         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
-        // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]               //OUTPUT: [00001001] [11000000] = {72, 96}
+        // [01001011] [01101110] [01101011] [10100000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]        //OUTPUT: [00001001] [11000000] = {72, 96}
         byte data16[] = new byte[5];
         startOffset = 3;
         numBits = 8;
@@ -433,7 +433,7 @@ public class BitBufferHelperTest {
         Assert.assertTrue(data16[2] == 0);
 
         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
-        // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]               //OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
+        // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]        //OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
         // OUTPUT: [00000100] [1011 0110] [1110 0000] = {4, -54, -96}
 
         startOffset = 3;
@@ -458,7 +458,7 @@ public class BitBufferHelperTest {
         Assert.assertTrue(data18[2] == -64);
 
         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
-        // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]               //OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
+        // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]        //OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
         // OUTPUT: [0000 1001] [0110 1101] [1100 1101] [0110 1010] [0000 0001] = {9, 109, -51, 106, 0}
 
         startOffset = 3;
@@ -472,7 +472,7 @@ public class BitBufferHelperTest {
         Assert.assertTrue(data19[4] == 0);
 
         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
-        // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]               //OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
+        // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]        //OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
         // OUTPUT: data[4, 5, 6] = [0 010 0101] [1 011 0111] [0 000 0000] = {37, -73, 0}
         startOffset = 33;
         numBits = 16;
@@ -484,7 +484,7 @@ public class BitBufferHelperTest {
 
         //CASE 4: extranumBits != 0 AND extraOffsetBits != 0
         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
-        // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]               //OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
+        // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]        //OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
         // OUTPUT: [0000 1001] [0100 0000]  = {9, 96}
         startOffset = 3;
         numBits = 7;
@@ -495,7 +495,7 @@ public class BitBufferHelperTest {
         Assert.assertTrue(data21[2] == 0);
 
         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
-        // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]               //OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
+        // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]        //OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
         // OUTPUT: data = [00000 010] [01011 011] [01110 000] = {37, -73, 0}
         startOffset = 5;
         numBits = 17;
@@ -506,7 +506,7 @@ public class BitBufferHelperTest {
         Assert.assertTrue(data22[2] == 112);
 
         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
-        // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]               //OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
+        // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]        //OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
         // OUTPUT: [0000 1001] [0110 1101] [110 01101] [01 00000] = {9, 109, -51, 64}
         startOffset = 3;
         numBits = 23;
@@ -518,7 +518,7 @@ public class BitBufferHelperTest {
         Assert.assertTrue(data23[3] == 64);
 
         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
-        // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]               //OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
+        // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]        //OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
         // OUTPUT: [0000 1001] [0110 1101]  = {9, 109}
         startOffset = 3;
         numBits = 13;
@@ -529,7 +529,7 @@ public class BitBufferHelperTest {
         Assert.assertTrue(data24[2] == 0);
 
         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
-        // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]               //OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
+        // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]        //OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
         // OUTPUT: [0000 0100] [1011 0110] [1110 0110]  = {4, -74, -26}
         startOffset = 4;
         numBits = 20;
@@ -541,7 +541,7 @@ public class BitBufferHelperTest {
         Assert.assertTrue(data25[3] == -0);
 
         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
-        // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]               //OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
+        // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]        //OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
         // OUTPUT: [0000 0010] [0101 1011]   = {0, 2, 91, 0}
         startOffset = 13;
         numBits = 11;
@@ -553,7 +553,7 @@ public class BitBufferHelperTest {
         Assert.assertTrue(data26[3] == 0);
 
         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
-        // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]               //OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
+        // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]        //OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
         // OUTPUT: [000 01001] [011 01101] [110 0 0000]   = {9, 109, -64, 0}
         startOffset = 3;
         numBits = 17;
@@ -565,7 +565,7 @@ public class BitBufferHelperTest {
         Assert.assertTrue(data27[3] == 0);
 
         // INPUT: {75, 110, 107, 80, 10, 12, 35, 100, 125, 65} =
-        // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]               //OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
+        // [01001011] [01101110] [01101011] [01010000] [00001010] [00001100] [00100011] [01100100] [11111101] [01000001]        //OUTPUT: [00000000] [00000100] [10110110] [11100000]= {0, 4, -54, -96}
         // OUTPUT: [00 000000] [00 000000] [00 010010] [11 011011] [10 011010] [11 010100] [0000 0000] = {0, 0, 18, -37,-102,-44,0}
         startOffset = 18;
         numBits = 34;