홍길동 / onos

Go to a project
Toggle navigation Toggle navigation pinning
mahesh poojary s
Committed by Gerrit Code Review
87977d1e 1 parent 7092b0e3

PcepErrorMsg UT updated for adding javadoc, remove log and if check. 

Change-Id: Iabab175b48f68461260cb45e7f127c13c575f130
Inline Side-by-side
Showing 1 changed file with 406 additions and 586 deletions
...@@ -15,45 +15,33 @@ ...@@ -15,45 +15,33 @@
15 */ 15 */
16 package org.onosproject.pcepio; 16 package org.onosproject.pcepio;
17 17
18 -import java.util.Arrays;
19 18
20 import org.jboss.netty.buffer.ChannelBuffer; 19 import org.jboss.netty.buffer.ChannelBuffer;
21 import org.jboss.netty.buffer.ChannelBuffers; 20 import org.jboss.netty.buffer.ChannelBuffers;
22 -import org.junit.After;
23 import org.junit.Assert; 21 import org.junit.Assert;
24 -import org.junit.Before;
25 import org.junit.Test; 22 import org.junit.Test;
26 import org.onosproject.pcepio.exceptions.PcepParseException; 23 import org.onosproject.pcepio.exceptions.PcepParseException;
27 import org.onosproject.pcepio.protocol.PcepErrorMsg; 24 import org.onosproject.pcepio.protocol.PcepErrorMsg;
28 import org.onosproject.pcepio.protocol.PcepFactories; 25 import org.onosproject.pcepio.protocol.PcepFactories;
29 import org.onosproject.pcepio.protocol.PcepMessage; 26 import org.onosproject.pcepio.protocol.PcepMessage;
30 import org.onosproject.pcepio.protocol.PcepMessageReader; 27 import org.onosproject.pcepio.protocol.PcepMessageReader;
31 -import org.slf4j.Logger;
32 -import org.slf4j.LoggerFactory;
33 28
34 /** 29 /**
35 * Test cases for PCEP ERROR Message. 30 * Test cases for PCEP ERROR Message.
36 */ 31 */
37 public class PcepErrorMsgTest { 32 public class PcepErrorMsgTest {
38 33
39 - protected static final Logger log = LoggerFactory.getLogger(PcepErrorMsgTest.class); 34 + /**
40 - 35 + * This test case checks for
41 - @Before 36 + * PCEP-ERROR Object, OPEN Object (STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV,
42 - public void startUp() { 37 + * PCECC-CAPABILITY-TLV, TED Capability TLV)
43 - 38 + * in PcepErrorMsg message.
44 - } 39 + *
45 - 40 + * @throws PcepParseException while parsing PCEP message
46 - @After 41 + */
47 - public void tearDown() {
48 -
49 - }
50 -
51 @Test 42 @Test
52 public void errorMessageTest1() throws PcepParseException { 43 public void errorMessageTest1() throws PcepParseException {
53 44
54 - /* PCEP-ERROR Object, OPEN Object (STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV,
55 - * PCECC-CAPABILITY-TLV, TED Capability TLV)
56 - */
57 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x34, // common header 45 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x34, // common header
58 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header 46 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
59 0x00, 0x00, 0x01, 0x01, 0x01, 0x10, 0x00, 0x28, // OPEN object header 47 0x00, 0x00, 0x01, 0x01, 0x01, 0x10, 0x00, 0x28, // OPEN object header
...@@ -69,39 +57,32 @@ public class PcepErrorMsgTest { ...@@ -69,39 +57,32 @@ public class PcepErrorMsgTest {
69 57
70 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); 58 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
71 PcepMessage message = null; 59 PcepMessage message = null;
72 - try {
73 - message = reader.readFrom(buffer);
74 - } catch (PcepParseException e) {
75 - e.printStackTrace();
76 - }
77 60
78 - byte[] testErrorMsg = {0}; 61 + message = reader.readFrom(buffer);
62 +
63 + byte[] testErrorMsg = {0 };
79 ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); 64 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
80 - if (message instanceof PcepErrorMsg) { 65 + Assert.assertTrue("PcepMessage is not instance of PcepErrorMsg", message instanceof PcepErrorMsg);
81 - message.writeTo(buf); 66 + message.writeTo(buf);
82 - int iReadLen = buf.writerIndex() - 0; 67 + int iReadLen = buf.writerIndex() - 0;
83 - testErrorMsg = new byte[iReadLen]; 68 + testErrorMsg = new byte[iReadLen];
84 - buf.readBytes(testErrorMsg, 0, iReadLen); 69 + buf.readBytes(testErrorMsg, 0, iReadLen);
85 - 70 +
86 - if (Arrays.equals(errorMsg, testErrorMsg)) { 71 + Assert.assertArrayEquals("PcepErrorMsg messages are not equal", errorMsg, testErrorMsg);
87 - Assert.assertArrayEquals(errorMsg, testErrorMsg); 72 +
88 - log.debug("Pcep Error Msg are Equal ");
89 - } else {
90 - Assert.fail("test case failed");
91 - log.debug("not equal");
92 - }
93 - } else {
94 - Assert.fail("test case failed");
95 - log.debug("not equal");
96 - }
97 } 73 }
98 74
75 + /**
76 + * This test case checks for
77 + * PCEP-ERROR Object, PCEP-ERROR Object, OPEN Object (STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV,
78 + * PCECC-CAPABILITY-TLV, TED Capability TLV)
79 + * in PcepErrorMsg message.
80 + *
81 + * @throws PcepParseException while parsing PCEP message
82 + */
99 @Test 83 @Test
100 public void errorMessageTest2() throws PcepParseException { 84 public void errorMessageTest2() throws PcepParseException {
101 85
102 - /* PCEP-ERROR Object, PCEP-ERROR Object, OPEN Object (STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV,
103 - * PCECC-CAPABILITY-TLV, TED Capability TLV)
104 - */
105 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x3C, // common header 86 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x3C, // common header
106 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header 87 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
107 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header 88 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
...@@ -118,39 +99,32 @@ public class PcepErrorMsgTest { ...@@ -118,39 +99,32 @@ public class PcepErrorMsgTest {
118 99
119 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); 100 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
120 PcepMessage message = null; 101 PcepMessage message = null;
121 - try {
122 - message = reader.readFrom(buffer);
123 - } catch (PcepParseException e) {
124 - e.printStackTrace();
125 - }
126 102
127 - byte[] testErrorMsg = {0}; 103 + message = reader.readFrom(buffer);
104 +
105 + byte[] testErrorMsg = {0 };
128 ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); 106 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
129 - if (message instanceof PcepErrorMsg) { 107 + Assert.assertTrue("PcepMessage is not instance of PcepErrorMsg", message instanceof PcepErrorMsg);
130 - message.writeTo(buf); 108 + message.writeTo(buf);
131 - int iReadLen = buf.writerIndex() - 0; 109 + int iReadLen = buf.writerIndex() - 0;
132 - testErrorMsg = new byte[iReadLen]; 110 + testErrorMsg = new byte[iReadLen];
133 - buf.readBytes(testErrorMsg, 0, iReadLen); 111 + buf.readBytes(testErrorMsg, 0, iReadLen);
134 - 112 +
135 - if (Arrays.equals(errorMsg, testErrorMsg)) { 113 + Assert.assertArrayEquals("PcepErrorMsg messages are not equal", errorMsg, testErrorMsg);
136 - Assert.assertArrayEquals(errorMsg, testErrorMsg); 114 +
137 - log.debug("Pcep Error Msg are Equal ");
138 - } else {
139 - Assert.fail("test case failed");
140 - log.debug("not equal");
141 - }
142 - } else {
143 - Assert.fail("test case failed");
144 - log.debug("not equal");
145 - }
146 } 115 }
147 116
117 + /**
118 + * This test case checks for
119 + * PCEP-ERROR Object, PCEP-ERROR Object, OPEN Object (STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV,
120 + * PCECC-CAPABILITY-TLV)
121 + * in PcepErrorMsg message.
122 + *
123 + * @throws PcepParseException while parsing PCEP message
124 + */
148 @Test 125 @Test
149 public void errorMessageTest3() throws PcepParseException { 126 public void errorMessageTest3() throws PcepParseException {
150 127
151 - /* PCEP-ERROR Object, PCEP-ERROR Object, OPEN Object (STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV,
152 - * PCECC-CAPABILITY-TLV)
153 - */
154 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x34, // common header 128 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x34, // common header
155 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header 129 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
156 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header 130 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
...@@ -166,37 +140,31 @@ public class PcepErrorMsgTest { ...@@ -166,37 +140,31 @@ public class PcepErrorMsgTest {
166 140
167 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); 141 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
168 PcepMessage message = null; 142 PcepMessage message = null;
169 - try {
170 - message = reader.readFrom(buffer);
171 - } catch (PcepParseException e) {
172 - e.printStackTrace();
173 - }
174 143
175 - byte[] testErrorMsg = {0}; 144 + message = reader.readFrom(buffer);
145 +
146 + byte[] testErrorMsg = {0 };
176 ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); 147 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
177 - if (message instanceof PcepErrorMsg) { 148 + Assert.assertTrue("PcepMessage is not instance of PcepErrorMsg", message instanceof PcepErrorMsg);
178 - message.writeTo(buf); 149 + message.writeTo(buf);
179 - int iReadLen = buf.writerIndex() - 0; 150 + int iReadLen = buf.writerIndex() - 0;
180 - testErrorMsg = new byte[iReadLen]; 151 + testErrorMsg = new byte[iReadLen];
181 - buf.readBytes(testErrorMsg, 0, iReadLen); 152 + buf.readBytes(testErrorMsg, 0, iReadLen);
182 - 153 +
183 - if (Arrays.equals(errorMsg, testErrorMsg)) { 154 + Assert.assertArrayEquals("PcepErrorMsg messages are not equal", errorMsg, testErrorMsg);
184 - Assert.assertArrayEquals(errorMsg, testErrorMsg); 155 +
185 - log.debug("Pcep Error Msg are Equal ");
186 - } else {
187 - Assert.fail("test case failed");
188 - log.debug("not equal");
189 - }
190 - } else {
191 - Assert.fail("test case failed");
192 - log.debug("not equal");
193 - }
194 } 156 }
195 157
158 + /**
159 + * This test case checks for
160 + * PCEP-ERROR Object, PCEP-ERROR Object, OPEN Object (STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV)
161 + * in PcepErrorMsg message.
162 + *
163 + * @throws PcepParseException while parsing PCEP message
164 + */
196 @Test 165 @Test
197 public void errorMessageTest4() throws PcepParseException { 166 public void errorMessageTest4() throws PcepParseException {
198 167
199 - //PCEP-ERROR Object, PCEP-ERROR Object, OPEN Object (STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV)
200 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x2c, // common header 168 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x2c, // common header
201 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header 169 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
202 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header 170 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
...@@ -211,37 +179,31 @@ public class PcepErrorMsgTest { ...@@ -211,37 +179,31 @@ public class PcepErrorMsgTest {
211 179
212 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); 180 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
213 PcepMessage message = null; 181 PcepMessage message = null;
214 - try {
215 - message = reader.readFrom(buffer);
216 - } catch (PcepParseException e) {
217 - e.printStackTrace();
218 - }
219 182
220 - byte[] testErrorMsg = {0}; 183 + message = reader.readFrom(buffer);
184 +
185 + byte[] testErrorMsg = {0 };
221 ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); 186 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
222 - if (message instanceof PcepErrorMsg) { 187 + Assert.assertTrue("PcepMessage is not instance of PcepErrorMsg", message instanceof PcepErrorMsg);
223 - message.writeTo(buf); 188 + message.writeTo(buf);
224 - int iReadLen = buf.writerIndex() - 0; 189 + int iReadLen = buf.writerIndex() - 0;
225 - testErrorMsg = new byte[iReadLen]; 190 + testErrorMsg = new byte[iReadLen];
226 - buf.readBytes(testErrorMsg, 0, iReadLen); 191 + buf.readBytes(testErrorMsg, 0, iReadLen);
227 - 192 +
228 - if (Arrays.equals(errorMsg, testErrorMsg)) { 193 + Assert.assertArrayEquals("PcepErrorMsg messages are not equal", errorMsg, testErrorMsg);
229 - Assert.assertArrayEquals(errorMsg, testErrorMsg); 194 +
230 - log.debug("Pcep Error Msg are Equal ");
231 - } else {
232 - Assert.fail("test case failed");
233 - log.debug("not equal");
234 - }
235 - } else {
236 - Assert.fail("test case failed");
237 - log.debug("not equal");
238 - }
239 } 195 }
240 196
197 + /**
198 + * This test case checks for
199 + * PCEP-ERROR Object, PCEP-ERROR Object, OPEN Object (STATEFUL-PCE-CAPABILITY)
200 + * in PcepErrorMsg message.
201 + *
202 + * @throws PcepParseException while parsing PCEP message
203 + */
241 @Test 204 @Test
242 public void errorMessageTest5() throws PcepParseException { 205 public void errorMessageTest5() throws PcepParseException {
243 206
244 - //PCEP-ERROR Object, PCEP-ERROR Object, OPEN Object (STATEFUL-PCE-CAPABILITY)
245 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x24, // common header 207 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x24, // common header
246 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header 208 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
247 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header 209 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
...@@ -255,37 +217,31 @@ public class PcepErrorMsgTest { ...@@ -255,37 +217,31 @@ public class PcepErrorMsgTest {
255 217
256 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); 218 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
257 PcepMessage message = null; 219 PcepMessage message = null;
258 - try {
259 - message = reader.readFrom(buffer);
260 - } catch (PcepParseException e) {
261 - e.printStackTrace();
262 - }
263 220
264 - byte[] testErrorMsg = {0}; 221 + message = reader.readFrom(buffer);
222 +
223 + byte[] testErrorMsg = {0 };
265 ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); 224 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
266 - if (message instanceof PcepErrorMsg) { 225 + Assert.assertTrue("PcepMessage is not instance of PcepErrorMsg", message instanceof PcepErrorMsg);
267 - message.writeTo(buf); 226 + message.writeTo(buf);
268 - int iReadLen = buf.writerIndex() - 0; 227 + int iReadLen = buf.writerIndex() - 0;
269 - testErrorMsg = new byte[iReadLen]; 228 + testErrorMsg = new byte[iReadLen];
270 - buf.readBytes(testErrorMsg, 0, iReadLen); 229 + buf.readBytes(testErrorMsg, 0, iReadLen);
271 - 230 +
272 - if (Arrays.equals(errorMsg, testErrorMsg)) { 231 + Assert.assertArrayEquals("PcepErrorMsg messages are not equal", errorMsg, testErrorMsg);
273 - Assert.assertArrayEquals(errorMsg, testErrorMsg); 232 +
274 - log.debug("Pcep Error Msg are Equal ");
275 - } else {
276 - Assert.fail("test case failed");
277 - log.debug("not equal");
278 - }
279 - } else {
280 - Assert.fail("test case failed");
281 - log.debug("not equal");
282 - }
283 } 233 }
284 234
235 + /**
236 + * This test case checks for
237 + * PCEP-ERROR Object, PCEP-ERROR Object, OPEN Object
238 + * in PcepErrorMsg message.
239 + *
240 + * @throws PcepParseException while parsing PCEP message
241 + */
285 @Test 242 @Test
286 public void errorMessageTest6() throws PcepParseException { 243 public void errorMessageTest6() throws PcepParseException {
287 244
288 - //PCEP-ERROR Object, PCEP-ERROR Object, OPEN Object
289 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x1C, // common header 245 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x1C, // common header
290 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header 246 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
291 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header 247 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
...@@ -298,37 +254,31 @@ public class PcepErrorMsgTest { ...@@ -298,37 +254,31 @@ public class PcepErrorMsgTest {
298 254
299 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); 255 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
300 PcepMessage message = null; 256 PcepMessage message = null;
301 - try {
302 - message = reader.readFrom(buffer);
303 - } catch (PcepParseException e) {
304 - e.printStackTrace();
305 - }
306 257
307 - byte[] testErrorMsg = {0}; 258 + message = reader.readFrom(buffer);
259 +
260 + byte[] testErrorMsg = {0 };
308 ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); 261 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
309 - if (message instanceof PcepErrorMsg) { 262 + Assert.assertTrue("PcepMessage is not instance of PcepErrorMsg", message instanceof PcepErrorMsg);
310 - message.writeTo(buf); 263 + message.writeTo(buf);
311 - int iReadLen = buf.writerIndex() - 0; 264 + int iReadLen = buf.writerIndex() - 0;
312 - testErrorMsg = new byte[iReadLen]; 265 + testErrorMsg = new byte[iReadLen];
313 - buf.readBytes(testErrorMsg, 0, iReadLen); 266 + buf.readBytes(testErrorMsg, 0, iReadLen);
314 - 267 +
315 - if (Arrays.equals(errorMsg, testErrorMsg)) { 268 + Assert.assertArrayEquals("PcepErrorMsg messages are not equal", errorMsg, testErrorMsg);
316 - Assert.assertArrayEquals(errorMsg, testErrorMsg); 269 +
317 - log.debug("Pcep Error Msg are Equal ");
318 - } else {
319 - Assert.fail("test case failed");
320 - log.debug("not equal");
321 - }
322 - } else {
323 - Assert.fail("test case failed");
324 - log.debug("not equal");
325 - }
326 } 270 }
327 271
272 + /**
273 + * This test case checks for
274 + * PCEP-ERROR Object, OPEN Object
275 + * in PcepErrorMsg message.
276 + *
277 + * @throws PcepParseException while parsing PCEP message
278 + */
328 @Test 279 @Test
329 public void errorMessageTest7() throws PcepParseException { 280 public void errorMessageTest7() throws PcepParseException {
330 281
331 - //PCEP-ERROR Object, OPEN Object
332 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x14, // common header 282 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x14, // common header
333 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header 283 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
334 0x00, 0x00, 0x01, 0x01, 0x01, 0x10, 0x00, 0x08, // OPEN object header 284 0x00, 0x00, 0x01, 0x01, 0x01, 0x10, 0x00, 0x08, // OPEN object header
...@@ -340,82 +290,67 @@ public class PcepErrorMsgTest { ...@@ -340,82 +290,67 @@ public class PcepErrorMsgTest {
340 290
341 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); 291 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
342 PcepMessage message = null; 292 PcepMessage message = null;
343 - try {
344 - message = reader.readFrom(buffer);
345 - } catch (PcepParseException e) {
346 - e.printStackTrace();
347 - }
348 293
349 - byte[] testErrorMsg = {0}; 294 + message = reader.readFrom(buffer);
295 +
296 + byte[] testErrorMsg = {0 };
350 ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); 297 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
351 - if (message instanceof PcepErrorMsg) { 298 + Assert.assertTrue("PcepMessage is not instance of PcepErrorMsg", message instanceof PcepErrorMsg);
352 - message.writeTo(buf); 299 + message.writeTo(buf);
353 - int iReadLen = buf.writerIndex() - 0; 300 + int iReadLen = buf.writerIndex() - 0;
354 - testErrorMsg = new byte[iReadLen]; 301 + testErrorMsg = new byte[iReadLen];
355 - buf.readBytes(testErrorMsg, 0, iReadLen); 302 + buf.readBytes(testErrorMsg, 0, iReadLen);
356 - 303 +
357 - if (Arrays.equals(errorMsg, testErrorMsg)) { 304 + Assert.assertArrayEquals("PcepErrorMsg messages are not equal", errorMsg, testErrorMsg);
358 - Assert.assertArrayEquals(errorMsg, testErrorMsg); 305 +
359 - log.debug("Pcep Error Msg are Equal ");
360 - } else {
361 - Assert.fail("test case failed");
362 - log.debug("not equal");
363 - }
364 - } else {
365 - Assert.fail("test case failed");
366 - log.debug("not equal");
367 - }
368 } 306 }
369 307
308 + /**
309 + * This test case checks for
310 + * PCEP-ERROR Object, RP Object, PCEP-ERROR Object
311 + * in PcepErrorMsg message.
312 + *
313 + * @throws PcepParseException while parsing PCEP message
314 + */
370 @Test 315 @Test
371 public void errorMessageTest8() throws PcepParseException { 316 public void errorMessageTest8() throws PcepParseException {
372 317
373 - //PCEP-ERROR Object, RP Object, PCEP-ERROR Object
374 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x20, // common header 318 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x20, // common header
375 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header 319 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
376 - 0x00, 0x00, 0x01, 0x01, 320 + 0x00, 0x00, 0x01, 0x01, 0x02, 0x10, 0x00, 0x0C, // RP Object Header
377 - 0x02, 0x10, 0x00, 0x0C, // RP Object Header 321 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
378 - 0x00, 0x00, 0x00, 0x00, 322 + 0x00, 0x00, 0x01, 0x03 };
379 - 0x00, 0x00, 0x00, 0x03,
380 - 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
381 - 0x00, 0x00, 0x01, 0x03};
382 323
383 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); 324 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
384 buffer.writeBytes(errorMsg); 325 buffer.writeBytes(errorMsg);
385 326
386 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); 327 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
387 PcepMessage message = null; 328 PcepMessage message = null;
388 - try {
389 - message = reader.readFrom(buffer);
390 - } catch (PcepParseException e) {
391 - e.printStackTrace();
392 - }
393 329
394 - byte[] testErrorMsg = {0}; 330 + message = reader.readFrom(buffer);
331 +
332 + byte[] testErrorMsg = {0 };
395 ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); 333 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
396 - if (message instanceof PcepErrorMsg) { 334 + Assert.assertTrue("PcepMessage is not instance of PcepErrorMsg", message instanceof PcepErrorMsg);
397 - message.writeTo(buf); 335 + message.writeTo(buf);
398 - int iReadLen = buf.writerIndex() - 0; 336 + int iReadLen = buf.writerIndex() - 0;
399 - testErrorMsg = new byte[iReadLen]; 337 + testErrorMsg = new byte[iReadLen];
400 - buf.readBytes(testErrorMsg, 0, iReadLen); 338 + buf.readBytes(testErrorMsg, 0, iReadLen);
401 - 339 +
402 - if (Arrays.equals(errorMsg, testErrorMsg)) { 340 + Assert.assertArrayEquals("PcepErrorMsg messages are not equal", errorMsg, testErrorMsg);
403 - Assert.assertArrayEquals(errorMsg, testErrorMsg); 341 +
404 - log.debug("Pcep Error Msg are Equal ");
405 - } else {
406 - Assert.fail("test case failed");
407 - log.debug("not equal");
408 - }
409 - } else {
410 - Assert.fail("test case failed");
411 - log.debug("not equal");
412 - }
413 } 342 }
414 343
344 + /**
345 + * This test case checks for
346 + * PCEP-ERROR Object, PCEP-ERROR Object
347 + * in PcepErrorMsg message.
348 + *
349 + * @throws PcepParseException while parsing PCEP message
350 + */
415 @Test 351 @Test
416 public void errorMessageTest9() throws PcepParseException { 352 public void errorMessageTest9() throws PcepParseException {
417 353
418 - //PCEP-ERROR Object, PCEP-ERROR Object
419 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x14, // common header 354 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x14, // common header
420 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header 355 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
421 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header 356 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
...@@ -426,37 +361,31 @@ public class PcepErrorMsgTest { ...@@ -426,37 +361,31 @@ public class PcepErrorMsgTest {
426 361
427 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); 362 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
428 PcepMessage message = null; 363 PcepMessage message = null;
429 - try {
430 - message = reader.readFrom(buffer);
431 - } catch (PcepParseException e) {
432 - e.printStackTrace();
433 - }
434 364
435 - byte[] testErrorMsg = {0}; 365 + message = reader.readFrom(buffer);
366 +
367 + byte[] testErrorMsg = {0 };
436 ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); 368 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
437 - if (message instanceof PcepErrorMsg) { 369 + Assert.assertTrue("PcepMessage is not instance of PcepErrorMsg", message instanceof PcepErrorMsg);
438 - message.writeTo(buf); 370 + message.writeTo(buf);
439 - int iReadLen = buf.writerIndex() - 0; 371 + int iReadLen = buf.writerIndex() - 0;
440 - testErrorMsg = new byte[iReadLen]; 372 + testErrorMsg = new byte[iReadLen];
441 - buf.readBytes(testErrorMsg, 0, iReadLen); 373 + buf.readBytes(testErrorMsg, 0, iReadLen);
442 - 374 +
443 - if (Arrays.equals(errorMsg, testErrorMsg)) { 375 + Assert.assertArrayEquals("PcepErrorMsg messages are not equal", errorMsg, testErrorMsg);
444 - Assert.assertArrayEquals(errorMsg, testErrorMsg); 376 +
445 - log.debug("Pcep Error Msg are Equal ");
446 - } else {
447 - Assert.fail("test case failed");
448 - log.debug("not equal");
449 - }
450 - } else {
451 - Assert.fail("test case failed");
452 - log.debug("not equal");
453 - }
454 } 377 }
455 378
379 + /**
380 + * This test case checks for
381 + * PCEP-ERROR Object, PCEP-ERROR Object
382 + * in PcepErrorMsg message.
383 + *
384 + * @throws PcepParseException while parsing PCEP message
385 + */
456 @Test 386 @Test
457 public void errorMessageTest10() throws PcepParseException { 387 public void errorMessageTest10() throws PcepParseException {
458 388
459 - //PCEP-ERROR Object, PCEP-ERROR Object
460 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x14, // common header 389 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x14, // common header
461 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header 390 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
462 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header 391 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
...@@ -467,37 +396,31 @@ public class PcepErrorMsgTest { ...@@ -467,37 +396,31 @@ public class PcepErrorMsgTest {
467 396
468 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); 397 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
469 PcepMessage message = null; 398 PcepMessage message = null;
470 - try {
471 - message = reader.readFrom(buffer);
472 - } catch (PcepParseException e) {
473 - e.printStackTrace();
474 - }
475 399
476 - byte[] testErrorMsg = {0}; 400 + message = reader.readFrom(buffer);
401 +
402 + byte[] testErrorMsg = {0 };
477 ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); 403 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
478 - if (message instanceof PcepErrorMsg) { 404 + Assert.assertTrue("PcepMessage is not instance of PcepErrorMsg", message instanceof PcepErrorMsg);
479 - message.writeTo(buf); 405 + message.writeTo(buf);
480 - int iReadLen = buf.writerIndex() - 0; 406 + int iReadLen = buf.writerIndex() - 0;
481 - testErrorMsg = new byte[iReadLen]; 407 + testErrorMsg = new byte[iReadLen];
482 - buf.readBytes(testErrorMsg, 0, iReadLen); 408 + buf.readBytes(testErrorMsg, 0, iReadLen);
483 - 409 +
484 - if (Arrays.equals(errorMsg, testErrorMsg)) { 410 + Assert.assertArrayEquals("PcepErrorMsg messages are not equal", errorMsg, testErrorMsg);
485 - Assert.assertArrayEquals(errorMsg, testErrorMsg); 411 +
486 - log.debug("Pcep Error Msg are Equal ");
487 - } else {
488 - Assert.fail("test case failed");
489 - log.debug("not equal");
490 - }
491 - } else {
492 - Assert.fail("test case failed");
493 - log.debug("not equal");
494 - }
495 } 412 }
496 413
414 + /**
415 + * This test case checks for
416 + * TE Object, PCEP-ERROR Object
417 + * in PcepErrorMsg message.
418 + *
419 + * @throws PcepParseException while parsing PCEP message
420 + */
497 @Test 421 @Test
498 public void errorMessageTest11() throws PcepParseException { 422 public void errorMessageTest11() throws PcepParseException {
499 423
500 - //TE Object, PCEP-ERROR Object
501 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x18, // common header 424 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x18, // common header
502 0x65, 0x13, 0x00, 0x0C, // TE Object Header 425 0x65, 0x13, 0x00, 0x0C, // TE Object Header
503 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID 426 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID
...@@ -509,467 +432,364 @@ public class PcepErrorMsgTest { ...@@ -509,467 +432,364 @@ public class PcepErrorMsgTest {
509 432
510 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); 433 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
511 PcepMessage message = null; 434 PcepMessage message = null;
512 - try {
513 - message = reader.readFrom(buffer);
514 - } catch (PcepParseException e) {
515 - e.printStackTrace();
516 - }
517 435
518 - byte[] testErrorMsg = {0}; 436 + message = reader.readFrom(buffer);
437 +
438 + byte[] testErrorMsg = {0 };
519 ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); 439 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
520 - if (message instanceof PcepErrorMsg) { 440 + Assert.assertTrue("PcepMessage is not instance of PcepErrorMsg", message instanceof PcepErrorMsg);
521 - message.writeTo(buf); 441 + message.writeTo(buf);
522 - int iReadLen = buf.writerIndex() - 0; 442 + int iReadLen = buf.writerIndex() - 0;
523 - testErrorMsg = new byte[iReadLen]; 443 + testErrorMsg = new byte[iReadLen];
524 - buf.readBytes(testErrorMsg, 0, iReadLen); 444 + buf.readBytes(testErrorMsg, 0, iReadLen);
525 - 445 +
526 - if (Arrays.equals(errorMsg, testErrorMsg)) { 446 + Assert.assertArrayEquals("PcepErrorMsg messages are not equal", errorMsg, testErrorMsg);
527 - Assert.assertArrayEquals(errorMsg, testErrorMsg); 447 +
528 - log.debug("Pcep Error Msg are Equal ");
529 - } else {
530 - Assert.fail("test case failed");
531 - log.debug("not equal");
532 - }
533 - } else {
534 - Assert.fail("test case failed");
535 - log.debug("not equal");
536 - }
537 } 448 }
538 449
450 + /**
451 + * This test case checks for
452 + * RP Object, PCEP-ERROR Object
453 + * in PcepErrorMsg message.
454 + *
455 + * @throws PcepParseException while parsing PCEP message
456 + */
539 @Test 457 @Test
540 public void errorMessageTest12() throws PcepParseException { 458 public void errorMessageTest12() throws PcepParseException {
541 459
542 //RP Object, PCEP-ERROR Object 460 //RP Object, PCEP-ERROR Object
543 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x18, // common header 461 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x18, // common header
544 0x02, 0x10, 0x00, 0x0C, // RP Object Header 462 0x02, 0x10, 0x00, 0x0C, // RP Object Header
545 - 0x00, 0x00, 0x00, 0x00, 463 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
546 - 0x00, 0x00, 0x00, 0x03, 464 + 0x00, 0x00, 0x01, 0x01 };
547 - 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
548 - 0x00, 0x00, 0x01, 0x01};
549 465
550 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); 466 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
551 buffer.writeBytes(errorMsg); 467 buffer.writeBytes(errorMsg);
552 468
553 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); 469 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
554 PcepMessage message = null; 470 PcepMessage message = null;
555 - try {
556 - message = reader.readFrom(buffer);
557 - } catch (PcepParseException e) {
558 - e.printStackTrace();
559 - }
560 471
561 - byte[] testErrorMsg = {0}; 472 + message = reader.readFrom(buffer);
473 +
474 + byte[] testErrorMsg = {0 };
562 ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); 475 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
563 - if (message instanceof PcepErrorMsg) { 476 + Assert.assertTrue("PcepMessage is not instance of PcepErrorMsg", message instanceof PcepErrorMsg);
564 - message.writeTo(buf); 477 + message.writeTo(buf);
565 - int iReadLen = buf.writerIndex() - 0; 478 + int iReadLen = buf.writerIndex() - 0;
566 - testErrorMsg = new byte[iReadLen]; 479 + testErrorMsg = new byte[iReadLen];
567 - buf.readBytes(testErrorMsg, 0, iReadLen); 480 + buf.readBytes(testErrorMsg, 0, iReadLen);
568 - 481 +
569 - if (Arrays.equals(errorMsg, testErrorMsg)) { 482 + Assert.assertArrayEquals("PcepErrorMsg messages are not equal", errorMsg, testErrorMsg);
570 - Assert.assertArrayEquals(errorMsg, testErrorMsg); 483 +
571 - log.debug("Pcep Error Msg are Equal ");
572 - } else {
573 - Assert.fail("test case failed");
574 - log.debug("not equal");
575 - }
576 - } else {
577 - Assert.fail("test case failed");
578 - log.debug("not equal");
579 - }
580 } 484 }
581 485
486 + /**
487 + * This test case checks for
488 + * RP Object, RP Object, PCEP-ERROR Object
489 + * in PcepErrorMsg message.
490 + *
491 + * @throws PcepParseException while parsing PCEP message
492 + */
582 @Test 493 @Test
583 public void errorMessageTest13() throws PcepParseException { 494 public void errorMessageTest13() throws PcepParseException {
584 495
585 - //RP Object, RP Object, PCEP-ERROR Object
586 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x24, // common header 496 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x24, // common header
587 0x02, 0x10, 0x00, 0x0C, // RP Object Header 497 0x02, 0x10, 0x00, 0x0C, // RP Object Header
588 - 0x00, 0x00, 0x00, 0x00, 498 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x02, 0x10, 0x00, 0x0C, // RP Object Header
589 - 0x00, 0x00, 0x00, 0x03, 499 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
590 - 0x02, 0x10, 0x00, 0x0C, // RP Object Header 500 + 0x00, 0x00, 0x01, 0x01 };
591 - 0x00, 0x00, 0x00, 0x00,
592 - 0x00, 0x00, 0x00, 0x04,
593 - 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
594 - 0x00, 0x00, 0x01, 0x01};
595 501
596 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); 502 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
597 buffer.writeBytes(errorMsg); 503 buffer.writeBytes(errorMsg);
598 504
599 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); 505 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
600 PcepMessage message = null; 506 PcepMessage message = null;
601 - try {
602 - message = reader.readFrom(buffer);
603 - } catch (PcepParseException e) {
604 - e.printStackTrace();
605 - }
606 507
607 - byte[] testErrorMsg = {0}; 508 + message = reader.readFrom(buffer);
509 +
510 + byte[] testErrorMsg = {0 };
608 ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); 511 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
609 - if (message instanceof PcepErrorMsg) { 512 + Assert.assertTrue("PcepMessage is not instance of PcepErrorMsg", message instanceof PcepErrorMsg);
610 - message.writeTo(buf); 513 + message.writeTo(buf);
611 - int iReadLen = buf.writerIndex() - 0; 514 + int iReadLen = buf.writerIndex() - 0;
612 - testErrorMsg = new byte[iReadLen]; 515 + testErrorMsg = new byte[iReadLen];
613 - buf.readBytes(testErrorMsg, 0, iReadLen); 516 + buf.readBytes(testErrorMsg, 0, iReadLen);
614 - 517 +
615 - if (Arrays.equals(errorMsg, testErrorMsg)) { 518 + Assert.assertArrayEquals("PcepErrorMsg messages are not equal", errorMsg, testErrorMsg);
616 - Assert.assertArrayEquals(errorMsg, testErrorMsg); 519 +
617 - log.debug("Pcep Error Msg are Equal ");
618 - } else {
619 - Assert.fail("test case failed");
620 - log.debug("not equal");
621 - }
622 - } else {
623 - Assert.fail("test case failed");
624 - log.debug("not equal");
625 - }
626 } 520 }
627 521
522 + /**
523 + * This test case checks for
524 + * TE Object, TE Object, PCEP-ERROR Object
525 + * in PcepErrorMsg message.
526 + *
527 + * @throws PcepParseException while parsing PCEP message
528 + */
628 @Test 529 @Test
629 public void errorMessageTest14() throws PcepParseException { 530 public void errorMessageTest14() throws PcepParseException {
630 531
631 - //TE Object, TE Object, PCEP-ERROR Object
632 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x24, // common header 532 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x24, // common header
633 0x65, 0x10, 0x00, 0x0C, // TE Object Header 533 0x65, 0x10, 0x00, 0x0C, // TE Object Header
634 - 0x01, 0x00, 0x00, 0x03, 534 + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID
635 - 0x00, 0x00, 0x00, 0x10, // TE-ID
636 0x65, 0x10, 0x00, 0x0C, // TE Object Header 535 0x65, 0x10, 0x00, 0x0C, // TE Object Header
637 - 0x01, 0x00, 0x00, 0x03, 536 + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x11, // TE-ID
638 - 0x00, 0x00, 0x00, 0x11, // TE-ID
639 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header 537 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
640 - 0x00, 0x00, 0x01, 0x01}; 538 + 0x00, 0x00, 0x01, 0x01 };
641 539
642 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); 540 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
643 buffer.writeBytes(errorMsg); 541 buffer.writeBytes(errorMsg);
644 542
645 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); 543 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
646 PcepMessage message = null; 544 PcepMessage message = null;
647 - try {
648 - message = reader.readFrom(buffer);
649 - } catch (PcepParseException e) {
650 - e.printStackTrace();
651 - }
652 545
653 - byte[] testErrorMsg = {0}; 546 + message = reader.readFrom(buffer);
547 +
548 + byte[] testErrorMsg = {0 };
654 ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); 549 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
655 - if (message instanceof PcepErrorMsg) { 550 + Assert.assertTrue("PcepMessage is not instance of PcepErrorMsg", message instanceof PcepErrorMsg);
656 - message.writeTo(buf); 551 + message.writeTo(buf);
657 - int iReadLen = buf.writerIndex() - 0; 552 + int iReadLen = buf.writerIndex() - 0;
658 - testErrorMsg = new byte[iReadLen]; 553 + testErrorMsg = new byte[iReadLen];
659 - buf.readBytes(testErrorMsg, 0, iReadLen); 554 + buf.readBytes(testErrorMsg, 0, iReadLen);
660 - 555 +
661 - if (Arrays.equals(errorMsg, testErrorMsg)) { 556 + Assert.assertArrayEquals("PcepErrorMsg messages are not equal", errorMsg, testErrorMsg);
662 - Assert.assertArrayEquals(errorMsg, testErrorMsg); 557 +
663 - log.debug("Pcep Error Msg are Equal ");
664 - } else {
665 - Assert.fail("test case failed");
666 - log.debug("not equal");
667 - }
668 - } else {
669 - Assert.fail("test case failed");
670 - log.debug("not equal");
671 - }
672 } 558 }
673 559
560 + /**
561 + * This test case checks for
562 + * PCEP-ERROR Object, TE Object, PCEP-ERROR Object
563 + * in PcepErrorMsg message.
564 + *
565 + * @throws PcepParseException while parsing PCEP message
566 + */
674 @Test 567 @Test
675 public void errorMessageTest15() throws PcepParseException { 568 public void errorMessageTest15() throws PcepParseException {
676 569
677 - //PCEP-ERROR Object, TE Object, PCEP-ERROR Object
678 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x20, // common header 570 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x20, // common header
679 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header 571 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
680 - 0x00, 0x00, 0x01, 0x01, 572 + 0x00, 0x00, 0x01, 0x01, 0x65, 0x10, 0x00, 0x0C, // TE Object Header
681 - 0x65, 0x10, 0x00, 0x0C, // TE Object Header 573 + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID
682 - 0x01, 0x00, 0x00, 0x03,
683 - 0x00, 0x00, 0x00, 0x10, // TE-ID
684 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header 574 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
685 - 0x00, 0x00, 0x01, 0x03}; 575 + 0x00, 0x00, 0x01, 0x03 };
686 576
687 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); 577 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
688 buffer.writeBytes(errorMsg); 578 buffer.writeBytes(errorMsg);
689 579
690 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); 580 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
691 PcepMessage message = null; 581 PcepMessage message = null;
692 - try {
693 - message = reader.readFrom(buffer);
694 - } catch (PcepParseException e) {
695 - e.printStackTrace();
696 - }
697 582
698 - byte[] testErrorMsg = {0}; 583 + message = reader.readFrom(buffer);
584 +
585 + byte[] testErrorMsg = {0 };
699 ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); 586 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
700 - if (message instanceof PcepErrorMsg) { 587 + Assert.assertTrue("PcepMessage is not instance of PcepErrorMsg", message instanceof PcepErrorMsg);
701 - message.writeTo(buf); 588 + message.writeTo(buf);
702 - int iReadLen = buf.writerIndex() - 0; 589 + int iReadLen = buf.writerIndex() - 0;
703 - testErrorMsg = new byte[iReadLen]; 590 + testErrorMsg = new byte[iReadLen];
704 - buf.readBytes(testErrorMsg, 0, iReadLen); 591 + buf.readBytes(testErrorMsg, 0, iReadLen);
705 - 592 +
706 - if (Arrays.equals(errorMsg, testErrorMsg)) { 593 + Assert.assertArrayEquals("PcepErrorMsg messages are not equal", errorMsg, testErrorMsg);
707 - Assert.assertArrayEquals(errorMsg, testErrorMsg); 594 +
708 - log.debug("Pcep Error Msg are Equal ");
709 - } else {
710 - Assert.fail("test case failed");
711 - log.debug("not equal");
712 - }
713 - } else {
714 - Assert.fail("test case failed");
715 - log.debug("not equal");
716 - }
717 } 595 }
718 596
597 + /**
598 + * This test case checks for
599 + * PCEP-ERROR Object, RP Object, RP Object, PCEP-ERROR Object
600 + * in PcepErrorMsg message.
601 + *
602 + * @throws PcepParseException while parsing PCEP message
603 + */
719 @Test 604 @Test
720 public void errorMessageTest16() throws PcepParseException { 605 public void errorMessageTest16() throws PcepParseException {
721 606
722 - //PCEP-ERROR Object, RP Object, RP Object, PCEP-ERROR Object
723 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x2C, // common header 607 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x2C, // common header
724 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header 608 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
725 - 0x00, 0x00, 0x01, 0x01, 609 + 0x00, 0x00, 0x01, 0x01, 0x02, 0x10, 0x00, 0x0C, // RP Object Header
726 - 0x02, 0x10, 0x00, 0x0C, // RP Object Header 610 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x02, 0x10, 0x00, 0x0C, // RP Object Header
727 - 0x00, 0x00, 0x00, 0x00, 611 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
728 - 0x00, 0x00, 0x00, 0x03, 612 + 0x00, 0x00, 0x01, 0x03 };
729 - 0x02, 0x10, 0x00, 0x0C, // RP Object Header
730 - 0x00, 0x00, 0x00, 0x00,
731 - 0x00, 0x00, 0x00, 0x04,
732 - 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
733 - 0x00, 0x00, 0x01, 0x03};
734 613
735 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); 614 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
736 buffer.writeBytes(errorMsg); 615 buffer.writeBytes(errorMsg);
737 616
738 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); 617 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
739 PcepMessage message = null; 618 PcepMessage message = null;
740 - try {
741 - message = reader.readFrom(buffer);
742 - } catch (PcepParseException e) {
743 - e.printStackTrace();
744 - }
745 619
746 - byte[] testErrorMsg = {0}; 620 + message = reader.readFrom(buffer);
621 +
622 + byte[] testErrorMsg = {0 };
747 ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); 623 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
748 - if (message instanceof PcepErrorMsg) { 624 + Assert.assertTrue("PcepMessage is not instance of PcepErrorMsg", message instanceof PcepErrorMsg);
749 - message.writeTo(buf); 625 + message.writeTo(buf);
750 - int iReadLen = buf.writerIndex() - 0; 626 + int iReadLen = buf.writerIndex() - 0;
751 - testErrorMsg = new byte[iReadLen]; 627 + testErrorMsg = new byte[iReadLen];
752 - buf.readBytes(testErrorMsg, 0, iReadLen); 628 + buf.readBytes(testErrorMsg, 0, iReadLen);
753 - 629 +
754 - if (Arrays.equals(errorMsg, testErrorMsg)) { 630 + Assert.assertArrayEquals("PcepErrorMsg messages are not equal", errorMsg, testErrorMsg);
755 - Assert.assertArrayEquals(errorMsg, testErrorMsg); 631 +
756 - log.debug("Pcep Error Msg are Equal ");
757 - } else {
758 - Assert.fail("test case failed");
759 - log.debug("not equal");
760 - }
761 - } else {
762 - Assert.fail("test case failed");
763 - log.debug("not equal");
764 - }
765 } 632 }
766 633
634 + /**
635 + * This test case checks for
636 + * PCEP-ERROR Object, TE Object, TE Object, PCEP-ERROR Object
637 + * in PcepErrorMsg message.
638 + *
639 + * @throws PcepParseException while parsing PCEP message
640 + */
767 @Test 641 @Test
768 public void errorMessageTest17() throws PcepParseException { 642 public void errorMessageTest17() throws PcepParseException {
769 643
770 - //PCEP-ERROR Object, TE Object, TE Object, PCEP-ERROR Object
771 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x2C, // common header 644 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x2C, // common header
772 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header 645 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
773 - 0x00, 0x00, 0x01, 0x01, 646 + 0x00, 0x00, 0x01, 0x01, 0x65, 0x10, 0x00, 0x0C, // TE Object Header
774 - 0x65, 0x10, 0x00, 0x0C, // TE Object Header 647 + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID
775 - 0x01, 0x00, 0x00, 0x03,
776 - 0x00, 0x00, 0x00, 0x10, // TE-ID
777 0x65, 0x10, 0x00, 0x0C, // TE Object Header 648 0x65, 0x10, 0x00, 0x0C, // TE Object Header
778 - 0x01, 0x00, 0x00, 0x03, 649 + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x11, // TE-ID
779 - 0x00, 0x00, 0x00, 0x11, // TE-ID
780 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header 650 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
781 - 0x00, 0x00, 0x01, 0x03}; 651 + 0x00, 0x00, 0x01, 0x03 };
782 652
783 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); 653 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
784 buffer.writeBytes(errorMsg); 654 buffer.writeBytes(errorMsg);
785 655
786 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); 656 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
787 PcepMessage message = null; 657 PcepMessage message = null;
788 - try {
789 - message = reader.readFrom(buffer);
790 - } catch (PcepParseException e) {
791 - e.printStackTrace();
792 - }
793 658
794 - byte[] testErrorMsg = {0}; 659 + message = reader.readFrom(buffer);
660 +
661 + byte[] testErrorMsg = {0 };
795 ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); 662 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
796 - if (message instanceof PcepErrorMsg) { 663 + Assert.assertTrue("PcepMessage is not instance of PcepErrorMsg", message instanceof PcepErrorMsg);
797 - message.writeTo(buf); 664 + message.writeTo(buf);
798 - int iReadLen = buf.writerIndex() - 0; 665 + int iReadLen = buf.writerIndex() - 0;
799 - testErrorMsg = new byte[iReadLen]; 666 + testErrorMsg = new byte[iReadLen];
800 - buf.readBytes(testErrorMsg, 0, iReadLen); 667 + buf.readBytes(testErrorMsg, 0, iReadLen);
801 - 668 +
802 - if (Arrays.equals(errorMsg, testErrorMsg)) { 669 + Assert.assertArrayEquals("PcepErrorMsg messages are not equal", errorMsg, testErrorMsg);
803 - Assert.assertArrayEquals(errorMsg, testErrorMsg); 670 +
804 - log.debug("Pcep Error Msg are Equal ");
805 - } else {
806 - Assert.fail("test case failed");
807 - log.debug("not equal");
808 - }
809 - } else {
810 - Assert.fail("test case failed");
811 - log.debug("not equal");
812 - }
813 } 671 }
814 672
673 + /**
674 + * This test case checks for
675 + * PCEP-ERROR Object, PCEP-ERROR Object, RP Object, RP Object, PCEP-ERROR Object, PCEP-ERROR Object
676 + * in PcepErrorMsg message.
677 + *
678 + * @throws PcepParseException while parsing PCEP message
679 + */
815 @Test 680 @Test
816 public void errorMessageTest18() throws PcepParseException { 681 public void errorMessageTest18() throws PcepParseException {
817 682
818 - //PCEP-ERROR Object, PCEP-ERROR Object, RP Object, RP Object, PCEP-ERROR Object, PCEP-ERROR Object
819 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x3C, // common header 683 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x3C, // common header
820 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header 684 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
821 - 0x00, 0x00, 0x01, 0x01, 685 + 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
822 - 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header 686 + 0x00, 0x00, 0x01, 0x03, 0x02, 0x10, 0x00, 0x0C, // RP Object Header
823 - 0x00, 0x00, 0x01, 0x03, 687 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x02, 0x10, 0x00, 0x0C, // RP Object Header
824 - 0x02, 0x10, 0x00, 0x0C, // RP Object Header 688 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
825 - 0x00, 0x00, 0x00, 0x00, 689 + 0x00, 0x00, 0x01, 0x04, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
826 - 0x00, 0x00, 0x00, 0x03, 690 + 0x00, 0x00, 0x01, 0x06 };
827 - 0x02, 0x10, 0x00, 0x0C, // RP Object Header
828 - 0x00, 0x00, 0x00, 0x00,
829 - 0x00, 0x00, 0x00, 0x04,
830 - 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
831 - 0x00, 0x00, 0x01, 0x04,
832 - 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
833 - 0x00, 0x00, 0x01, 0x06};
834 691
835 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); 692 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
836 buffer.writeBytes(errorMsg); 693 buffer.writeBytes(errorMsg);
837 694
838 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); 695 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
839 PcepMessage message = null; 696 PcepMessage message = null;
840 - try {
841 - message = reader.readFrom(buffer);
842 - } catch (PcepParseException e) {
843 - e.printStackTrace();
844 - }
845 697
846 - byte[] testErrorMsg = {0}; 698 + message = reader.readFrom(buffer);
699 +
700 + byte[] testErrorMsg = {0 };
847 ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); 701 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
848 - if (message instanceof PcepErrorMsg) { 702 + Assert.assertTrue("PcepMessage is not instance of PcepErrorMsg", message instanceof PcepErrorMsg);
849 - message.writeTo(buf); 703 + message.writeTo(buf);
850 - int iReadLen = buf.writerIndex() - 0; 704 + int iReadLen = buf.writerIndex() - 0;
851 - testErrorMsg = new byte[iReadLen]; 705 + testErrorMsg = new byte[iReadLen];
852 - buf.readBytes(testErrorMsg, 0, iReadLen); 706 + buf.readBytes(testErrorMsg, 0, iReadLen);
853 - 707 +
854 - if (Arrays.equals(errorMsg, testErrorMsg)) { 708 + Assert.assertArrayEquals("PcepErrorMsg messages are not equal", errorMsg, testErrorMsg);
855 - Assert.assertArrayEquals(errorMsg, testErrorMsg); 709 +
856 - log.debug("Pcep Error Msg are Equal ");
857 - } else {
858 - Assert.fail("test case failed");
859 - log.debug("not equal");
860 - }
861 - } else {
862 - Assert.fail("test case failed");
863 - log.debug("not equal");
864 - }
865 } 710 }
866 711
712 + /**
713 + * This test case checks for
714 + * PCEP-ERROR Object, PCEP-ERROR Object, TE Object, TE Object, PCEP-ERROR Object, PCEP-ERROR Object
715 + * in PcepErrorMsg message.
716 + *
717 + * @throws PcepParseException while parsing PCEP message
718 + */
867 @Test 719 @Test
868 public void errorMessageTest19() throws PcepParseException { 720 public void errorMessageTest19() throws PcepParseException {
869 721
870 - //PCEP-ERROR Object, PCEP-ERROR Object, TE Object, TE Object, PCEP-ERROR Object, PCEP-ERROR Object
871 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x3C, // common header 722 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x3C, // common header
872 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header 723 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
873 - 0x00, 0x00, 0x01, 0x01, 724 + 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
874 - 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header 725 + 0x00, 0x00, 0x01, 0x03, 0x65, 0x10, 0x00, 0x0C, // TE Object Header
875 - 0x00, 0x00, 0x01, 0x03, 726 + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID
876 - 0x65, 0x10, 0x00, 0x0C, // TE Object Header
877 - 0x01, 0x00, 0x00, 0x03,
878 - 0x00, 0x00, 0x00, 0x10, // TE-ID
879 0x65, 0x10, 0x00, 0x0C, // TE Object Header 727 0x65, 0x10, 0x00, 0x0C, // TE Object Header
880 - 0x01, 0x00, 0x00, 0x03, 728 + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x11, // TE-ID
881 - 0x00, 0x00, 0x00, 0x11, // TE-ID
882 - 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
883 - 0x00, 0x00, 0x01, 0x04,
884 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header 729 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
885 - 0x00, 0x00, 0x01, 0x06}; 730 + 0x00, 0x00, 0x01, 0x04, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
731 + 0x00, 0x00, 0x01, 0x06 };
886 732
887 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); 733 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
888 buffer.writeBytes(errorMsg); 734 buffer.writeBytes(errorMsg);
889 735
890 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); 736 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
891 PcepMessage message = null; 737 PcepMessage message = null;
892 - try {
893 - message = reader.readFrom(buffer);
894 - } catch (PcepParseException e) {
895 - e.printStackTrace();
896 - }
897 738
898 - byte[] testErrorMsg = {0}; 739 + message = reader.readFrom(buffer);
740 +
741 + byte[] testErrorMsg = {0 };
899 ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); 742 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
900 - if (message instanceof PcepErrorMsg) { 743 + Assert.assertTrue("PcepMessage is not instance of PcepErrorMsg", message instanceof PcepErrorMsg);
901 - message.writeTo(buf); 744 + message.writeTo(buf);
902 - int iReadLen = buf.writerIndex() - 0; 745 + int iReadLen = buf.writerIndex() - 0;
903 - testErrorMsg = new byte[iReadLen]; 746 + testErrorMsg = new byte[iReadLen];
904 - buf.readBytes(testErrorMsg, 0, iReadLen); 747 + buf.readBytes(testErrorMsg, 0, iReadLen);
905 - 748 +
906 - if (Arrays.equals(errorMsg, testErrorMsg)) { 749 + Assert.assertArrayEquals("PcepErrorMsg messages are not equal", errorMsg, testErrorMsg);
907 - Assert.assertArrayEquals(errorMsg, testErrorMsg); 750 +
908 - log.debug("Pcep Error Msg are Equal ");
909 - } else {
910 - Assert.fail("test case failed");
911 - log.debug("not equal");
912 - }
913 - } else {
914 - Assert.fail("test case failed");
915 - log.debug("not equal");
916 - }
917 } 751 }
918 752
753 + /**
754 + * This test case checks for
755 + * PCEP-ERROR Object, RP Object, RP Object, PCEP-ERROR Object, PCEP-ERROR Object,
756 + * TE Object, PCEP-ERROR Object
757 + * in PcepErrorMsg message.
758 + *
759 + * @throws PcepParseException while parsing PCEP message
760 + */
919 @Test 761 @Test
920 public void errorMessageTest20() throws PcepParseException { 762 public void errorMessageTest20() throws PcepParseException {
921 763
922 - /* PCEP-ERROR Object, RP Object, RP Object, PCEP-ERROR Object, PCEP-ERROR Object,
923 - * TE Object, PCEP-ERROR Object
924 - */
925 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x48, // common header 764 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x48, // common header
926 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header 765 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
927 - 0x00, 0x00, 0x01, 0x01, 766 + 0x00, 0x00, 0x01, 0x01, 0x02, 0x10, 0x00, 0x0C, // RP Object Header
928 - 0x02, 0x10, 0x00, 0x0C, // RP Object Header 767 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x02, 0x10, 0x00, 0x0C, // RP Object Header
929 - 0x00, 0x00, 0x00, 0x00, 768 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
930 - 0x00, 0x00, 0x00, 0x03, 769 + 0x00, 0x00, 0x01, 0x04, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
931 - 0x02, 0x10, 0x00, 0x0C, // RP Object Header 770 + 0x00, 0x00, 0x01, 0x06, 0x65, 0x10, 0x00, 0x0C, // TE Object Header
932 - 0x00, 0x00, 0x00, 0x00, 771 + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID
933 - 0x00, 0x00, 0x00, 0x04,
934 - 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
935 - 0x00, 0x00, 0x01, 0x04,
936 - 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
937 - 0x00, 0x00, 0x01, 0x06,
938 - 0x65, 0x10, 0x00, 0x0C, // TE Object Header
939 - 0x01, 0x00, 0x00, 0x03,
940 - 0x00, 0x00, 0x00, 0x10, // TE-ID
941 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header 772 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
942 - 0x00, 0x00, 0x01, 0x06}; 773 + 0x00, 0x00, 0x01, 0x06 };
943 774
944 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); 775 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
945 buffer.writeBytes(errorMsg); 776 buffer.writeBytes(errorMsg);
946 777
947 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); 778 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
948 PcepMessage message = null; 779 PcepMessage message = null;
949 - try {
950 - message = reader.readFrom(buffer);
951 - } catch (PcepParseException e) {
952 - e.printStackTrace();
953 - }
954 780
955 - byte[] testErrorMsg = {0}; 781 + message = reader.readFrom(buffer);
782 +
783 + byte[] testErrorMsg = {0 };
956 ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); 784 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
957 - if (message instanceof PcepErrorMsg) { 785 + Assert.assertTrue("PcepMessage is not instance of PcepErrorMsg", message instanceof PcepErrorMsg);
958 - message.writeTo(buf); 786 +
959 - int iReadLen = buf.writerIndex() - 0; 787 + message.writeTo(buf);
960 - testErrorMsg = new byte[iReadLen]; 788 + int iReadLen = buf.writerIndex() - 0;
961 - buf.readBytes(testErrorMsg, 0, iReadLen); 789 + testErrorMsg = new byte[iReadLen];
962 - 790 + buf.readBytes(testErrorMsg, 0, iReadLen);
963 - if (Arrays.equals(errorMsg, testErrorMsg)) { 791 +
964 - Assert.assertArrayEquals(errorMsg, testErrorMsg); 792 + Assert.assertArrayEquals("PcepErrorMsg messages are not equal", errorMsg, testErrorMsg);
965 - log.debug("Pcep Error Msg are Equal "); 793 +
966 - } else {
967 - Assert.fail("test case failed");
968 - log.debug("not equal");
969 - }
970 - } else {
971 - Assert.fail("test case failed");
972 - log.debug("not equal");
973 - }
974 } 794 }
975 } 795 }
......