Gitiles
Code Review Sign In
gerrit.onosproject.org / onos / 1c356e329939efce093c1005c8ea65a36f80390b / . / pcep / pcepio / src / test / java / org / onosproject / pcepio / PcepErrorMsgTest.java
blob: 1dca8c0528203af9d2a12129ac13b24dc946e81b [file] [log] [blame]
Mahesh Poojary S1c356e32015-08-21 15:05:30 +0530[diff] [blame^]1/*
2 * Copyright 2014-2015 Open Networking Laboratory
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16package org.onosproject.pcepio;
17
18import java.util.Arrays;
19
20import org.jboss.netty.buffer.ChannelBuffer;
21import org.jboss.netty.buffer.ChannelBuffers;
22import org.junit.After;
23import org.junit.Assert;
24import org.junit.Before;
25import org.junit.Test;
26import org.onosproject.pcepio.exceptions.PcepParseException;
27import org.onosproject.pcepio.protocol.PcepErrorMsg;
28import org.onosproject.pcepio.protocol.PcepFactories;
29import org.onosproject.pcepio.protocol.PcepMessage;
30import org.onosproject.pcepio.protocol.PcepMessageReader;
31import org.slf4j.Logger;
32import org.slf4j.LoggerFactory;
33
34/**
35 * Test cases for PCEP ERROR Message.
36 */
37public class PcepErrorMsgTest {
38
39 protected static final Logger log = LoggerFactory.getLogger(PcepErrorMsgTest.class);
40
41 @Before
42 public void startUp() {
43
44 }
45
46 @After
47 public void tearDown() {
48
49 }
50
51 @Test
52 public void errorMessageTest1() throws PcepParseException {
53
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
58 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
59 0x00, 0x00, 0x01, 0x01, 0x01, 0x10, 0x00, 0x28, // OPEN object header
60 0x20, 0x05, 0x1E, 0x01, // OPEN object
61 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY
62 0x00, 0x00, 0x00, 0x05, 0x00, 0x0E, 0x00, 0x04, // GMPLS-CAPABILITY-TLV
63 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, // PCECC-CAPABILITY-TLV
64 0x00, 0x00, 0x00, 0x03, 0x00, (byte) 0x84, 0x00, 0x04, // TED Capability TLV
65 0x00, 0x00, 0x00, 0x00 };
66
67 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
68 buffer.writeBytes(errorMsg);
69
70 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
71 PcepMessage message = null;
72 try {
73 message = reader.readFrom(buffer);
74 } catch (PcepParseException e) {
75 e.printStackTrace();
76 }
77
78 byte[] testErrorMsg = {0};
79 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
80 if (message instanceof PcepErrorMsg) {
81 message.writeTo(buf);
82 int iReadLen = buf.writerIndex() - 0;
83 testErrorMsg = new byte[iReadLen];
84 buf.readBytes(testErrorMsg, 0, iReadLen);
85
86 if (Arrays.equals(errorMsg, testErrorMsg)) {
87 Assert.assertArrayEquals(errorMsg, testErrorMsg);
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 }
98
99 @Test
100 public void errorMessageTest2() throws PcepParseException {
101
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
106 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
107 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
108 0x00, 0x00, 0x01, 0x03, 0x01, 0x10, 0x00, 0x28, // OPEN object header
109 0x20, 0x05, 0x1E, 0x01, // OPEN object
110 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY
111 0x00, 0x00, 0x00, 0x05, 0x00, 0x0E, 0x00, 0x04, // GMPLS-CAPABILITY-TLV
112 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, // PCECC-CAPABILITY-TLV
113 0x00, 0x00, 0x00, 0x03, 0x00, (byte) 0x84, 0x00, 0x04, // TED Capability TLV
114 0x00, 0x00, 0x00, 0x00 };
115
116 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
117 buffer.writeBytes(errorMsg);
118
119 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
120 PcepMessage message = null;
121 try {
122 message = reader.readFrom(buffer);
123 } catch (PcepParseException e) {
124 e.printStackTrace();
125 }
126
127 byte[] testErrorMsg = {0};
128 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
129 if (message instanceof PcepErrorMsg) {
130 message.writeTo(buf);
131 int iReadLen = buf.writerIndex() - 0;
132 testErrorMsg = new byte[iReadLen];
133 buf.readBytes(testErrorMsg, 0, iReadLen);
134
135 if (Arrays.equals(errorMsg, testErrorMsg)) {
136 Assert.assertArrayEquals(errorMsg, testErrorMsg);
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 }
147
148 @Test
149 public void errorMessageTest3() throws PcepParseException {
150
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
155 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
156 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
157 0x00, 0x00, 0x01, 0x03, 0x01, 0x10, 0x00, 0x20, // OPEN object header
158 0x20, 0x05, 0x1E, 0x01, // OPEN object
159 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY
160 0x00, 0x00, 0x00, 0x05, 0x00, 0x0E, 0x00, 0x04, // GMPLS-CAPABILITY-TLV
161 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, // PCECC-CAPABILITY-TLV
162 0x00, 0x00, 0x00, 0x03 };
163
164 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
165 buffer.writeBytes(errorMsg);
166
167 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
168 PcepMessage message = null;
169 try {
170 message = reader.readFrom(buffer);
171 } catch (PcepParseException e) {
172 e.printStackTrace();
173 }
174
175 byte[] testErrorMsg = {0};
176 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
177 if (message instanceof PcepErrorMsg) {
178 message.writeTo(buf);
179 int iReadLen = buf.writerIndex() - 0;
180 testErrorMsg = new byte[iReadLen];
181 buf.readBytes(testErrorMsg, 0, iReadLen);
182
183 if (Arrays.equals(errorMsg, testErrorMsg)) {
184 Assert.assertArrayEquals(errorMsg, testErrorMsg);
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 }
195
196 @Test
197 public void errorMessageTest4() throws PcepParseException {
198
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
201 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
202 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
203 0x00, 0x00, 0x01, 0x03, 0x01, 0x10, 0x00, 0x18, // OPEN object header
204 0x20, 0x05, 0x1E, 0x01, // OPEN object
205 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY
206 0x00, 0x00, 0x00, 0x05, 0x00, 0x0E, 0x00, 0x04, // GMPLS-CAPABILITY-TLV
207 0x00, 0x00, 0x00, 0x00 };
208
209 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
210 buffer.writeBytes(errorMsg);
211
212 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
213 PcepMessage message = null;
214 try {
215 message = reader.readFrom(buffer);
216 } catch (PcepParseException e) {
217 e.printStackTrace();
218 }
219
220 byte[] testErrorMsg = {0};
221 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
222 if (message instanceof PcepErrorMsg) {
223 message.writeTo(buf);
224 int iReadLen = buf.writerIndex() - 0;
225 testErrorMsg = new byte[iReadLen];
226 buf.readBytes(testErrorMsg, 0, iReadLen);
227
228 if (Arrays.equals(errorMsg, testErrorMsg)) {
229 Assert.assertArrayEquals(errorMsg, testErrorMsg);
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 }
240
241 @Test
242 public void errorMessageTest5() throws PcepParseException {
243
244 //PCEP-ERROR Object, PCEP-ERROR Object, OPEN Object (STATEFUL-PCE-CAPABILITY)
245 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x24, // common header
246 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
247 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
248 0x00, 0x00, 0x01, 0x03, 0x01, 0x10, 0x00, 0x10, // OPEN object header
249 0x20, 0x05, 0x1E, 0x01, // OPEN object
250 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY
251 0x00, 0x00, 0x00, 0x05 };
252
253 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
254 buffer.writeBytes(errorMsg);
255
256 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
257 PcepMessage message = null;
258 try {
259 message = reader.readFrom(buffer);
260 } catch (PcepParseException e) {
261 e.printStackTrace();
262 }
263
264 byte[] testErrorMsg = {0};
265 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
266 if (message instanceof PcepErrorMsg) {
267 message.writeTo(buf);
268 int iReadLen = buf.writerIndex() - 0;
269 testErrorMsg = new byte[iReadLen];
270 buf.readBytes(testErrorMsg, 0, iReadLen);
271
272 if (Arrays.equals(errorMsg, testErrorMsg)) {
273 Assert.assertArrayEquals(errorMsg, testErrorMsg);
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 }
284
285 @Test
286 public void errorMessageTest6() throws PcepParseException {
287
288 //PCEP-ERROR Object, PCEP-ERROR Object, OPEN Object
289 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x1C, // common header
290 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
291 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
292 0x00, 0x00, 0x01, 0x03, 0x01, 0x10, 0x00, 0x08, // OPEN object header
293 0x20, 0x05, 0x1E, 0x01 // OPEN object
294 };
295
296 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
297 buffer.writeBytes(errorMsg);
298
299 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
300 PcepMessage message = null;
301 try {
302 message = reader.readFrom(buffer);
303 } catch (PcepParseException e) {
304 e.printStackTrace();
305 }
306
307 byte[] testErrorMsg = {0};
308 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
309 if (message instanceof PcepErrorMsg) {
310 message.writeTo(buf);
311 int iReadLen = buf.writerIndex() - 0;
312 testErrorMsg = new byte[iReadLen];
313 buf.readBytes(testErrorMsg, 0, iReadLen);
314
315 if (Arrays.equals(errorMsg, testErrorMsg)) {
316 Assert.assertArrayEquals(errorMsg, testErrorMsg);
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 }
327
328 @Test
329 public void errorMessageTest7() throws PcepParseException {
330
331 //PCEP-ERROR Object, OPEN Object
332 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x14, // common header
333 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
334 0x00, 0x00, 0x01, 0x01, 0x01, 0x10, 0x00, 0x08, // OPEN object header
335 0x20, 0x05, 0x1E, 0x01 // OPEN object
336 };
337
338 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
339 buffer.writeBytes(errorMsg);
340
341 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
342 PcepMessage message = null;
343 try {
344 message = reader.readFrom(buffer);
345 } catch (PcepParseException e) {
346 e.printStackTrace();
347 }
348
349 byte[] testErrorMsg = {0};
350 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
351 if (message instanceof PcepErrorMsg) {
352 message.writeTo(buf);
353 int iReadLen = buf.writerIndex() - 0;
354 testErrorMsg = new byte[iReadLen];
355 buf.readBytes(testErrorMsg, 0, iReadLen);
356
357 if (Arrays.equals(errorMsg, testErrorMsg)) {
358 Assert.assertArrayEquals(errorMsg, testErrorMsg);
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 }
369
370 @Test
371 public void errorMessageTest8() throws PcepParseException {
372
373 //PCEP-ERROR Object, RP Object, PCEP-ERROR Object
374 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x20, // common header
375 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
376 0x00, 0x00, 0x01, 0x01,
377 0x02, 0x10, 0x00, 0x0C, // RP Object Header
378 0x00, 0x00, 0x00, 0x00,
379 0x00, 0x00, 0x00, 0x03,
380 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
381 0x00, 0x00, 0x01, 0x03};
382
383 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
384 buffer.writeBytes(errorMsg);
385
386 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
387 PcepMessage message = null;
388 try {
389 message = reader.readFrom(buffer);
390 } catch (PcepParseException e) {
391 e.printStackTrace();
392 }
393
394 byte[] testErrorMsg = {0};
395 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
396 if (message instanceof PcepErrorMsg) {
397 message.writeTo(buf);
398 int iReadLen = buf.writerIndex() - 0;
399 testErrorMsg = new byte[iReadLen];
400 buf.readBytes(testErrorMsg, 0, iReadLen);
401
402 if (Arrays.equals(errorMsg, testErrorMsg)) {
403 Assert.assertArrayEquals(errorMsg, testErrorMsg);
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 }
414
415 @Test
416 public void errorMessageTest9() throws PcepParseException {
417
418 //PCEP-ERROR Object, PCEP-ERROR Object
419 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x14, // common header
420 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
421 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
422 0x00, 0x00, 0x01, 0x01 };
423
424 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
425 buffer.writeBytes(errorMsg);
426
427 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
428 PcepMessage message = null;
429 try {
430 message = reader.readFrom(buffer);
431 } catch (PcepParseException e) {
432 e.printStackTrace();
433 }
434
435 byte[] testErrorMsg = {0};
436 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
437 if (message instanceof PcepErrorMsg) {
438 message.writeTo(buf);
439 int iReadLen = buf.writerIndex() - 0;
440 testErrorMsg = new byte[iReadLen];
441 buf.readBytes(testErrorMsg, 0, iReadLen);
442
443 if (Arrays.equals(errorMsg, testErrorMsg)) {
444 Assert.assertArrayEquals(errorMsg, testErrorMsg);
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 }
455
456 @Test
457 public void errorMessageTest10() throws PcepParseException {
458
459 //PCEP-ERROR Object, PCEP-ERROR Object
460 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x14, // common header
461 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
462 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
463 0x00, 0x00, 0x01, 0x01 };
464
465 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
466 buffer.writeBytes(errorMsg);
467
468 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
469 PcepMessage message = null;
470 try {
471 message = reader.readFrom(buffer);
472 } catch (PcepParseException e) {
473 e.printStackTrace();
474 }
475
476 byte[] testErrorMsg = {0};
477 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
478 if (message instanceof PcepErrorMsg) {
479 message.writeTo(buf);
480 int iReadLen = buf.writerIndex() - 0;
481 testErrorMsg = new byte[iReadLen];
482 buf.readBytes(testErrorMsg, 0, iReadLen);
483
484 if (Arrays.equals(errorMsg, testErrorMsg)) {
485 Assert.assertArrayEquals(errorMsg, testErrorMsg);
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 }
496
497 @Test
498 public void errorMessageTest11() throws PcepParseException {
499
500 //TE Object, PCEP-ERROR Object
501 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x18, // common header
502 0x65, 0x13, 0x00, 0x0C, // TE Object Header
503 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID
504 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
505 0x00, 0x00, 0x01, 0x01 };
506
507 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
508 buffer.writeBytes(errorMsg);
509
510 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
511 PcepMessage message = null;
512 try {
513 message = reader.readFrom(buffer);
514 } catch (PcepParseException e) {
515 e.printStackTrace();
516 }
517
518 byte[] testErrorMsg = {0};
519 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
520 if (message instanceof PcepErrorMsg) {
521 message.writeTo(buf);
522 int iReadLen = buf.writerIndex() - 0;
523 testErrorMsg = new byte[iReadLen];
524 buf.readBytes(testErrorMsg, 0, iReadLen);
525
526 if (Arrays.equals(errorMsg, testErrorMsg)) {
527 Assert.assertArrayEquals(errorMsg, testErrorMsg);
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 }
538
539 @Test
540 public void errorMessageTest12() throws PcepParseException {
541
542 //RP Object, PCEP-ERROR Object
543 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x18, // common header
544 0x02, 0x10, 0x00, 0x0C, // RP Object Header
545 0x00, 0x00, 0x00, 0x00,
546 0x00, 0x00, 0x00, 0x03,
547 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
548 0x00, 0x00, 0x01, 0x01};
549
550 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
551 buffer.writeBytes(errorMsg);
552
553 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
554 PcepMessage message = null;
555 try {
556 message = reader.readFrom(buffer);
557 } catch (PcepParseException e) {
558 e.printStackTrace();
559 }
560
561 byte[] testErrorMsg = {0};
562 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
563 if (message instanceof PcepErrorMsg) {
564 message.writeTo(buf);
565 int iReadLen = buf.writerIndex() - 0;
566 testErrorMsg = new byte[iReadLen];
567 buf.readBytes(testErrorMsg, 0, iReadLen);
568
569 if (Arrays.equals(errorMsg, testErrorMsg)) {
570 Assert.assertArrayEquals(errorMsg, testErrorMsg);
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 }
581
582 @Test
583 public void errorMessageTest13() throws PcepParseException {
584
585 //RP Object, RP Object, PCEP-ERROR Object
586 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x24, // common header
587 0x02, 0x10, 0x00, 0x0C, // RP Object Header
588 0x00, 0x00, 0x00, 0x00,
589 0x00, 0x00, 0x00, 0x03,
590 0x02, 0x10, 0x00, 0x0C, // RP Object Header
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
596 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
597 buffer.writeBytes(errorMsg);
598
599 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
600 PcepMessage message = null;
601 try {
602 message = reader.readFrom(buffer);
603 } catch (PcepParseException e) {
604 e.printStackTrace();
605 }
606
607 byte[] testErrorMsg = {0};
608 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
609 if (message instanceof PcepErrorMsg) {
610 message.writeTo(buf);
611 int iReadLen = buf.writerIndex() - 0;
612 testErrorMsg = new byte[iReadLen];
613 buf.readBytes(testErrorMsg, 0, iReadLen);
614
615 if (Arrays.equals(errorMsg, testErrorMsg)) {
616 Assert.assertArrayEquals(errorMsg, testErrorMsg);
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 }
627
628 @Test
629 public void errorMessageTest14() throws PcepParseException {
630
631 //TE Object, TE Object, PCEP-ERROR Object
632 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x24, // common header
633 0x65, 0x10, 0x00, 0x0C, // TE Object Header
634 0x01, 0x00, 0x00, 0x03,
635 0x00, 0x00, 0x00, 0x10, // TE-ID
636 0x65, 0x10, 0x00, 0x0C, // TE Object Header
637 0x01, 0x00, 0x00, 0x03,
638 0x00, 0x00, 0x00, 0x11, // TE-ID
639 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
640 0x00, 0x00, 0x01, 0x01};
641
642 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
643 buffer.writeBytes(errorMsg);
644
645 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
646 PcepMessage message = null;
647 try {
648 message = reader.readFrom(buffer);
649 } catch (PcepParseException e) {
650 e.printStackTrace();
651 }
652
653 byte[] testErrorMsg = {0};
654 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
655 if (message instanceof PcepErrorMsg) {
656 message.writeTo(buf);
657 int iReadLen = buf.writerIndex() - 0;
658 testErrorMsg = new byte[iReadLen];
659 buf.readBytes(testErrorMsg, 0, iReadLen);
660
661 if (Arrays.equals(errorMsg, testErrorMsg)) {
662 Assert.assertArrayEquals(errorMsg, testErrorMsg);
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 }
673
674 @Test
675 public void errorMessageTest15() throws PcepParseException {
676
677 //PCEP-ERROR Object, TE Object, PCEP-ERROR Object
678 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x20, // common header
679 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
680 0x00, 0x00, 0x01, 0x01,
681 0x65, 0x10, 0x00, 0x0C, // TE Object Header
682 0x01, 0x00, 0x00, 0x03,
683 0x00, 0x00, 0x00, 0x10, // TE-ID
684 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
685 0x00, 0x00, 0x01, 0x03};
686
687 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
688 buffer.writeBytes(errorMsg);
689
690 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
691 PcepMessage message = null;
692 try {
693 message = reader.readFrom(buffer);
694 } catch (PcepParseException e) {
695 e.printStackTrace();
696 }
697
698 byte[] testErrorMsg = {0};
699 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
700 if (message instanceof PcepErrorMsg) {
701 message.writeTo(buf);
702 int iReadLen = buf.writerIndex() - 0;
703 testErrorMsg = new byte[iReadLen];
704 buf.readBytes(testErrorMsg, 0, iReadLen);
705
706 if (Arrays.equals(errorMsg, testErrorMsg)) {
707 Assert.assertArrayEquals(errorMsg, testErrorMsg);
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 }
718
719 @Test
720 public void errorMessageTest16() throws PcepParseException {
721
722 //PCEP-ERROR Object, RP Object, RP Object, PCEP-ERROR Object
723 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x2C, // common header
724 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
725 0x00, 0x00, 0x01, 0x01,
726 0x02, 0x10, 0x00, 0x0C, // RP Object Header
727 0x00, 0x00, 0x00, 0x00,
728 0x00, 0x00, 0x00, 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
735 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
736 buffer.writeBytes(errorMsg);
737
738 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
739 PcepMessage message = null;
740 try {
741 message = reader.readFrom(buffer);
742 } catch (PcepParseException e) {
743 e.printStackTrace();
744 }
745
746 byte[] testErrorMsg = {0};
747 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
748 if (message instanceof PcepErrorMsg) {
749 message.writeTo(buf);
750 int iReadLen = buf.writerIndex() - 0;
751 testErrorMsg = new byte[iReadLen];
752 buf.readBytes(testErrorMsg, 0, iReadLen);
753
754 if (Arrays.equals(errorMsg, testErrorMsg)) {
755 Assert.assertArrayEquals(errorMsg, testErrorMsg);
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 }
766
767 @Test
768 public void errorMessageTest17() throws PcepParseException {
769
770 //PCEP-ERROR Object, TE Object, TE Object, PCEP-ERROR Object
771 byte[] errorMsg = new byte[] {0x20, 0x06, 0x00, 0x2C, // common header
772 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
773 0x00, 0x00, 0x01, 0x01,
774 0x65, 0x10, 0x00, 0x0C, // TE Object Header
775 0x01, 0x00, 0x00, 0x03,
776 0x00, 0x00, 0x00, 0x10, // TE-ID
777 0x65, 0x10, 0x00, 0x0C, // TE Object Header
778 0x01, 0x00, 0x00, 0x03,
779 0x00, 0x00, 0x00, 0x11, // TE-ID
780 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
781 0x00, 0x00, 0x01, 0x03};
782
783 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
784 buffer.writeBytes(errorMsg);
785
786 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
787 PcepMessage message = null;
788 try {
789 message = reader.readFrom(buffer);
790 } catch (PcepParseException e) {
791 e.printStackTrace();
792 }
793
794 byte[] testErrorMsg = {0};
795 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
796 if (message instanceof PcepErrorMsg) {
797 message.writeTo(buf);
798 int iReadLen = buf.writerIndex() - 0;
799 testErrorMsg = new byte[iReadLen];
800 buf.readBytes(testErrorMsg, 0, iReadLen);
801
802 if (Arrays.equals(errorMsg, testErrorMsg)) {
803 Assert.assertArrayEquals(errorMsg, testErrorMsg);
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 }
814
815 @Test
816 public void errorMessageTest18() throws PcepParseException {
817
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
820 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
821 0x00, 0x00, 0x01, 0x01,
822 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
823 0x00, 0x00, 0x01, 0x03,
824 0x02, 0x10, 0x00, 0x0C, // RP Object Header
825 0x00, 0x00, 0x00, 0x00,
826 0x00, 0x00, 0x00, 0x03,
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
835 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
836 buffer.writeBytes(errorMsg);
837
838 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
839 PcepMessage message = null;
840 try {
841 message = reader.readFrom(buffer);
842 } catch (PcepParseException e) {
843 e.printStackTrace();
844 }
845
846 byte[] testErrorMsg = {0};
847 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
848 if (message instanceof PcepErrorMsg) {
849 message.writeTo(buf);
850 int iReadLen = buf.writerIndex() - 0;
851 testErrorMsg = new byte[iReadLen];
852 buf.readBytes(testErrorMsg, 0, iReadLen);
853
854 if (Arrays.equals(errorMsg, testErrorMsg)) {
855 Assert.assertArrayEquals(errorMsg, testErrorMsg);
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 }
866
867 @Test
868 public void errorMessageTest19() throws PcepParseException {
869
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
872 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
873 0x00, 0x00, 0x01, 0x01,
874 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header
875 0x00, 0x00, 0x01, 0x03,
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
880 0x01, 0x00, 0x00, 0x03,
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
885 0x00, 0x00, 0x01, 0x06};
886
887 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
888 buffer.writeBytes(errorMsg);
889
890 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
891 PcepMessage message = null;
892 try {
893 message = reader.readFrom(buffer);
894 } catch (PcepParseException e) {
895 e.printStackTrace();
896 }
897
898 byte[] testErrorMsg = {0};
899 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
900 if (message instanceof PcepErrorMsg) {
901 message.writeTo(buf);
902 int iReadLen = buf.writerIndex() - 0;
903 testErrorMsg = new byte[iReadLen];
904 buf.readBytes(testErrorMsg, 0, iReadLen);
905
906 if (Arrays.equals(errorMsg, testErrorMsg)) {
907 Assert.assertArrayEquals(errorMsg, testErrorMsg);
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 }
918
919 @Test
920 public void errorMessageTest20() throws PcepParseException {
921
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
926 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header
927 0x00, 0x00, 0x01, 0x01,
928 0x02, 0x10, 0x00, 0x0C, // RP Object Header
929 0x00, 0x00, 0x00, 0x00,
930 0x00, 0x00, 0x00, 0x03,
931 0x02, 0x10, 0x00, 0x0C, // RP Object Header
932 0x00, 0x00, 0x00, 0x00,
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
942 0x00, 0x00, 0x01, 0x06};
943
944 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
945 buffer.writeBytes(errorMsg);
946
947 PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader();
948 PcepMessage message = null;
949 try {
950 message = reader.readFrom(buffer);
951 } catch (PcepParseException e) {
952 e.printStackTrace();
953 }
954
955 byte[] testErrorMsg = {0};
956 ChannelBuffer buf = ChannelBuffers.dynamicBuffer();
957 if (message instanceof PcepErrorMsg) {
958 message.writeTo(buf);
959 int iReadLen = buf.writerIndex() - 0;
960 testErrorMsg = new byte[iReadLen];
961 buf.readBytes(testErrorMsg, 0, iReadLen);
962
963 if (Arrays.equals(errorMsg, testErrorMsg)) {
964 Assert.assertArrayEquals(errorMsg, testErrorMsg);
965 log.debug("Pcep Error Msg are Equal ");
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 }
975}