Gitiles
Code Review Sign In
gerrit.onosproject.org / onos / 5837837b78f72169e70c511486c58ff3864ddeac / . / protocols / bgp / bgpio / src / test / java / org / onosproject / bgpio / protocol / BgpUpdateMsgTest.java
blob: 8e1cd20268fb5b1939d6348f75148215d036a4d1 [file] [log] [blame]
Vidyashree Rama7ba6b4c2015-11-30 17:20:22 +0530[diff] [blame]1/*
2 * Copyright 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.bgpio.protocol;
17
18
19import static org.hamcrest.MatcherAssert.assertThat;
20import static org.hamcrest.Matchers.instanceOf;
21import static org.hamcrest.core.Is.is;
22
23import org.jboss.netty.buffer.ChannelBuffer;
24import org.jboss.netty.buffer.ChannelBuffers;
25import org.junit.Test;
26import org.onlab.packet.IpAddress;
27import org.onlab.packet.IpPrefix;
28import org.onosproject.bgpio.exceptions.BgpParseException;
29import org.onosproject.bgpio.protocol.linkstate.BgpLinkLsNlriVer4;
30import org.onosproject.bgpio.protocol.linkstate.BgpNodeLSIdentifier;
31import org.onosproject.bgpio.protocol.linkstate.BgpNodeLSNlriVer4;
32import org.onosproject.bgpio.protocol.linkstate.BgpNodeLSNlriVer4.ProtocolType;
33import org.onosproject.bgpio.protocol.linkstate.NodeDescriptors;
34import org.onosproject.bgpio.protocol.ver4.BgpPathAttributes;
35import org.onosproject.bgpio.types.As4Path;
36import org.onosproject.bgpio.types.AsPath;
37import org.onosproject.bgpio.types.AutonomousSystemTlv;
38import org.onosproject.bgpio.types.BgpHeader;
39import org.onosproject.bgpio.types.BgpLSIdentifierTlv;
40import org.onosproject.bgpio.types.BgpValueType;
41import org.onosproject.bgpio.types.IPReachabilityInformationTlv;
42import org.onosproject.bgpio.types.IsIsNonPseudonode;
43import org.onosproject.bgpio.types.IsIsPseudonode;
44import org.onosproject.bgpio.types.Med;
45import org.onosproject.bgpio.types.MpReachNlri;
46import org.onosproject.bgpio.types.MpUnReachNlri;
47import org.onosproject.bgpio.types.Origin;
48import org.onosproject.bgpio.types.NextHop;
49import org.onosproject.bgpio.types.LocalPref;
50import org.onosproject.bgpio.types.Origin.ORIGINTYPE;
51import org.slf4j.Logger;
52import org.slf4j.LoggerFactory;
53
54import java.util.LinkedList;
55import java.util.List;
56import java.util.ListIterator;
57
58/**
59 * Test cases for BGP update Message.
60 */
61public class BgpUpdateMsgTest {
62 protected static final Logger log = LoggerFactory.getLogger(BgpUpdateMsgTest.class);
63 public static final byte[] MARKER = new byte[]{(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
64 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
65 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff};
66 public static final byte UPDATE_MSG_TYPE = 0x2;
67
68 /**
69 * This test case checks update message with no withdrawn routes
70 * and path attributes.
71 */
72 @Test
73 public void bgpUpdateMessageTest01() throws BgpParseException {
74 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
75 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
76 (byte) 0xff, (byte) 0xff, 0x00, 0x17, 0x02, 0x00, 0x00, 0x00, 0x00};
77
78 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
79 buffer.writeBytes(updateMsg);
80
81 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
82 BgpMessage message;
83 BgpHeader bgpHeader = new BgpHeader();
84
85 message = reader.readFrom(buffer, bgpHeader);
86
87 assertThat(message, instanceOf(BgpUpdateMsg.class));
88 BgpUpdateMsg other = (BgpUpdateMsg) message;
89
90 assertThat(other.getHeader().getMarker(), is(MARKER));
91 assertThat(other.getHeader().getType(), is(UPDATE_MSG_TYPE));
92 assertThat(other.getHeader().getLength(), is((short) 23));
93 }
94
95 /**
96 * In this test case, Marker is set as 0 in input and expecting
97 * an exception.
98 */
99 @Test(expected = BgpParseException.class)
100 public void bgpUpdateMessageTest02() throws BgpParseException {
101 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
102 0x00, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
103 (byte) 0xff, (byte) 0xff, 0x00, 0x17, 0x02, 0x00, 0x00, 0x00, 0x00};
104
105 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
106 buffer.writeBytes(updateMsg);
107
108 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
109 BgpMessage message;
110 BgpHeader bgpHeader = new BgpHeader();
111 message = reader.readFrom(buffer, bgpHeader);
112
113 assertThat(message, instanceOf(BgpUpdateMsg.class));
114 }
115
116 /**
117 * In this test case, Invalid message length is given as input and expecting
118 * an exception.
119 */
120 @Test(expected = BgpParseException.class)
121 public void bgpUpdateMessageTest03() throws BgpParseException {
122 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
123 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
124 (byte) 0xff, (byte) 0xff, (byte) 0xff, 0x00, 0x18, 0x02, 0x00, 0x00, 0x00, 0x00};
125
126 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
127 buffer.writeBytes(updateMsg);
128
129 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
130 BgpMessage message;
131 BgpHeader bgpHeader = new BgpHeader();
132 message = reader.readFrom(buffer, bgpHeader);
133
134 assertThat(message, instanceOf(BgpUpdateMsg.class));
135 }
136
137 /**
138 * In this test case, Invalid message type is given as input and expecting
139 * an exception.
140 */
141 @Test(expected = BgpParseException.class)
142 public void bgpUpdateMessageTest04() throws BgpParseException {
143 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
144 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
145 (byte) 0xff, (byte) 0xff, (byte) 0xff, 0x00, 0x17, 0x06, 0x00, 0x00, 0x00, 0x00};
146
147 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
148 buffer.writeBytes(updateMsg);
149
150 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
151 BgpMessage message;
152 BgpHeader bgpHeader = new BgpHeader();
153 message = reader.readFrom(buffer, bgpHeader);
154
155 assertThat(message, instanceOf(BgpUpdateMsg.class));
156 }
157
158 /**
159 * This test case checks update message with withdrawn routes.
160 */
161 @Test
162 public void bgpUpdateMessageTest05() throws BgpParseException {
163 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
164 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
165 (byte) 0xff, (byte) 0xff, 0x00, 0x1b, 0x02, 0x00, 0x04, 0x18, 0x0a, 0x01, 0x01, 0x00, 0x00};
166
167 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
168 buffer.writeBytes(updateMsg);
169
170 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
171 BgpMessage message;
172 BgpHeader bgpHeader = new BgpHeader();
173
174 message = reader.readFrom(buffer, bgpHeader);
175
176 assertThat(message, instanceOf(BgpUpdateMsg.class));
177 BgpUpdateMsg other = (BgpUpdateMsg) message;
178
179 assertThat(other.getHeader().getMarker(), is(MARKER));
180 assertThat(other.getHeader().getType(), is(UPDATE_MSG_TYPE));
181 assertThat(other.getHeader().getLength(), is((short) 27));
182
183 ListIterator<IpPrefix> listIterator1 = other.withdrawnRoutes().listIterator();
184 byte[] prefix = new byte[] {0x0a, 0x01, 0x01, 0x00};
185
186 IpPrefix testPrefixValue = listIterator1.next();
187 assertThat(testPrefixValue.prefixLength(), is((int) 24));
188 assertThat(testPrefixValue.address().toOctets(), is(prefix));
189 }
190
191 /**
192 * In this test case, Invalid withdrawn route length is given as input and expecting
193 * an exception.
194 */
195 @Test(expected = BgpParseException.class)
196 public void bgpUpdateMessageTest06() throws BgpParseException {
197 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
198 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
199 (byte) 0xff, (byte) 0xff, 0x00, 0x1b, 0x02, 0x00, 0x04, 0x19, 0x0a, 0x01, 0x01, 0x00, 0x00};
200
201 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
202 buffer.writeBytes(updateMsg);
203
204 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
205 BgpMessage message;
206 BgpHeader bgpHeader = new BgpHeader();
207
208 message = reader.readFrom(buffer, bgpHeader);
209
210 assertThat(message, instanceOf(BgpUpdateMsg.class));
211 }
212
213 /**
214 * This test case checks update message with path attributes.
215 */
216 @Test
217 public void bgpUpdateMessageTest07() throws BgpParseException {
218 byte[] updateMsg = new byte [] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
219 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
220 (byte) 0xff, (byte) 0xff, 0x00, 0x3f, 0x02, 0x00, 0x00, 0x00, 0x1c, 0x40, 0x01, 0x01,
221 0x00, 0x40, 0x02, 0x00, 0x40, 0x03, 0x04, 0x03, 0x03, 0x03, 0x03, (byte) 0x80, 0x04, 0x04, 0x00, 0x00,
222 0x00, 0x00, 0x40, 0x05, 0x04, 0x00, 0x00, 0x00, 0x64, 0x18, 0x0a, 0x1e, 0x03, 0x18, 0x0a, 0x1e,
223 0x02, 0x18, 0x0a, 0x1e, 0x01};
224
225 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
226 buffer.writeBytes(updateMsg);
227
228 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
229 BgpMessage message;
230 BgpHeader bgpHeader = new BgpHeader();
231
232 message = reader.readFrom(buffer, bgpHeader);
233
234 assertThat(message, instanceOf(BgpUpdateMsg.class));
235 BgpUpdateMsg other = (BgpUpdateMsg) message;
236
237 assertThat(other.getHeader().getMarker(), is(MARKER));
238 assertThat(other.getHeader().getType(), is(UPDATE_MSG_TYPE));
239 assertThat(other.getHeader().getLength(), is((short) 63));
240
241 BgpValueType testPathAttribute;
242 Origin origin;
243 AsPath asPath;
244 NextHop nexthop;
245 Med med;
246 LocalPref localPref;
247
248 List<BgpValueType> pathAttributes = new LinkedList<>();
249 BgpPathAttributes actualpathAttribute = other.bgpPathAttributes();
250 pathAttributes = actualpathAttribute.pathAttributes();
251 ListIterator<BgpValueType> listIterator = pathAttributes.listIterator();
252 ORIGINTYPE originValue = org.onosproject.bgpio.types.Origin.ORIGINTYPE.IGP;
253
254 testPathAttribute = listIterator.next();
255 origin = (Origin) testPathAttribute;
256 assertThat(origin.origin(), is(originValue));
257
258 testPathAttribute = listIterator.next(); // AS PATH value is empty in hex dump
259 asPath = (AsPath) testPathAttribute;
260 List<Short> asPathValues = asPath.asPathSeq();
261 assertThat(asPathValues.isEmpty(), is(true));
262
263 testPathAttribute = listIterator.next();
264 nexthop = (NextHop) testPathAttribute;
265 byte[] nextHopAddr = new byte[] {0x03, 0x03, 0x03, 0x03};
266 assertThat(nexthop.nextHop().toOctets(), is(nextHopAddr));
267
268 testPathAttribute = listIterator.next();
269 med = (Med) testPathAttribute;
270 assertThat(med.med(), is(0));
271
272 testPathAttribute = listIterator.next();
273 localPref = (LocalPref) testPathAttribute;
274 assertThat(localPref.localPref(), is(100));
275
276 ListIterator<IpPrefix> listIterator1 = other.nlri().listIterator();
277 byte[] prefix = new byte[] {0x0a, 0x1e, 0x03, 0x00};
278
279 IpPrefix testPrefixValue = listIterator1.next();
280 assertThat(testPrefixValue.prefixLength(), is((int) 24));
281 assertThat(testPrefixValue.address().toOctets(), is(prefix));
282 }
283
284 /**
285 * In this test case, Invalid ORIGIN flags is given as input and expecting
286 * an exception.
287 */
288 @Test(expected = BgpParseException.class)
289 public void bgpUpdateMessageTest08() throws BgpParseException {
290 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
291 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
292 (byte) 0xff, (byte) 0xff, 0x00, 0x60, 0x02, 0x00, 0x00, //withdrawn len
293 0x00, 0x49, //path attribute len
294 (byte) 0xff, 0x01, 0x01, 0x00, //origin
295 0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd, (byte) 0xe9, //as_path
296 (byte) 0x80, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, //med
297 (byte) 0x80, 0x0e, 0x34, 0x40, 0x04, 0x47, //mpreach with safi = 71
298 0x04, 0x04, 0x00, 0x00, 0x01, //nexthop
299 0x00, //reserved
300 0x00, 0x01, 0x00,
301 0x27, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x1a, 0x02, 0x00,
302 0x00, 0x04, 0x00, 0x00, 0x08, (byte) 0xae, 0x02, 0x01, 0x00, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03,
303 0x00, 0x06, 0x19, 0x00, (byte) 0x95, 0x01, (byte) 0x90, 0x58}; //node nlri};
304
305 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
306 buffer.writeBytes(updateMsg);
307
308 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
309 BgpMessage message;
310 BgpHeader bgpHeader = new BgpHeader();
311
312 message = reader.readFrom(buffer, bgpHeader);
313
314 assertThat(message, instanceOf(BgpUpdateMsg.class));
315 }
316
317 /**
318 * In this test case, Invalid ORIGIN value is given as input and expecting
319 * an exception.
320 */
321 @Test(expected = BgpParseException.class)
322 public void bgpUpdateMessageTest09() throws BgpParseException {
323 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
324 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
325 (byte) 0xff, (byte) 0xff, 0x00, 0x60, 0x02, 0x00, 0x00, //withdrawn len
326 0x00, 0x49, //path attribute len
327 (byte) 0xff, 0x01, 0x04, 0x00, //origin
328 0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd, (byte) 0xe9, //as_path
329 (byte) 0x80, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, //med
330 (byte) 0x80, 0x0e, 0x34, 0x40, 0x04, 0x47, //mpreach with safi = 71
331 0x04, 0x04, 0x00, 0x00, 0x01, //nexthop
332 0x00, //reserved
333 0x00, 0x01, 0x00,
334 0x27, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x1a, 0x02, 0x00,
335 0x00, 0x04, 0x00, 0x00, 0x08, (byte) 0xae, 0x02, 0x01, 0x00, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03,
336 0x00, 0x06, 0x19, 0x00, (byte) 0x95, 0x01, (byte) 0x90, 0x58}; //node nlri};
337
338 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
339 buffer.writeBytes(updateMsg);
340
341 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
342 BgpMessage message;
343 BgpHeader bgpHeader = new BgpHeader();
344
345 message = reader.readFrom(buffer, bgpHeader);
346
347 assertThat(message, instanceOf(BgpUpdateMsg.class));
348 }
349
350 /**
351 * In this test case, update message without path attribute is given as input and expecting
352 * an exception.
353 */
354 @Test(expected = BgpParseException.class)
355 public void bgpUpdateMessageTest10() throws BgpParseException {
356 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
357 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
358 (byte) 0xff, (byte) 0xff, 0x00, 0x1a, 0x02, 0x00, 0x04, 0x18, 0x0a, 0x01, 0x01, 0x00};
359
360 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
361 buffer.writeBytes(updateMsg);
362
363 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
364 BgpMessage message;
365 BgpHeader bgpHeader = new BgpHeader();
366
367 message = reader.readFrom(buffer, bgpHeader);
368
369 assertThat(message, instanceOf(BgpUpdateMsg.class));
370 }
371
372 /**
373 * In this test case, update message with incorrect path attribute length is given as input and expecting
374 * an exception.
375 */
376 @Test(expected = BgpParseException.class)
377 public void bgpUpdateMessageTest11() throws BgpParseException {
378 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
379 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
380 (byte) 0xff, (byte) 0xff, 0x00, 0x1b, 0x02, 0x00, 0x04, 0x18, 0x0a, 0x01, 0x01, 0x00, 0x01};
381
382 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
383 buffer.writeBytes(updateMsg);
384
385 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
386 BgpMessage message;
387 BgpHeader bgpHeader = new BgpHeader();
388
389 message = reader.readFrom(buffer, bgpHeader);
390
391 assertThat(message, instanceOf(BgpUpdateMsg.class));
392 }
393
394 /**
395 * In this test case, Invalid MED flags is given as input and expecting
396 * an exception.
397 */
398 @Test(expected = BgpParseException.class)
399 public void bgpUpdateMessageTest12() throws BgpParseException {
400 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
401 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
402 (byte) 0xff, (byte) 0xff, 0x00, 0x60, 0x02, 0x00, 0x00, //withdrawn len
403 0x00, 0x49, //path attribute len
404 (byte) 0xff, 0x01, 0x01, 0x00, //origin
405 0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd, (byte) 0xe9, //as_path
406 (byte) 0xff, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, //med
407 (byte) 0x80, 0x0e, 0x34, 0x40, 0x04, 0x47, //mpreach with safi = 71
408 0x04, 0x04, 0x00, 0x00, 0x01, //nexthop
409 0x00, //reserved
410 0x00, 0x01, 0x00,
411 0x27, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x1a, 0x02, 0x00,
412 0x00, 0x04, 0x00, 0x00, 0x08, (byte) 0xae, 0x02, 0x01, 0x00, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03,
413 0x00, 0x06, 0x19, 0x00, (byte) 0x95, 0x01, (byte) 0x90, 0x58}; //node nlri};
414
415 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
416 buffer.writeBytes(updateMsg);
417
418 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
419 BgpMessage message;
420 BgpHeader bgpHeader = new BgpHeader();
421
422 message = reader.readFrom(buffer, bgpHeader);
423
424 assertThat(message, instanceOf(BgpUpdateMsg.class));
425 }
426
427 /**
428 * In this test case, Invalid AS Path flags is given as input and expecting
429 * an exception.
430 */
431 @Test(expected = BgpParseException.class)
432 public void bgpUpdateMessageTest13() throws BgpParseException {
433 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
434 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
435 (byte) 0xff, (byte) 0xff, 0x00, 0x60, 0x02, 0x00, 0x00, //withdrawn len
436 0x00, 0x49, //path attribute len
437 (byte) 0xff, 0x01, 0x01, 0x00, //origin
438 (byte) 0xff, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd, (byte) 0xe9, //as_path
439 (byte) 0x80, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, //med
440 (byte) 0x80, 0x0e, 0x34, 0x40, 0x04, 0x47, //mpreach with safi = 71
441 0x04, 0x04, 0x00, 0x00, 0x01, //nexthop
442 0x00, //reserved
443 0x00, 0x01, 0x00,
444 0x27, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x1a, 0x02, 0x00,
445 0x00, 0x04, 0x00, 0x00, 0x08, (byte) 0xae, 0x02, 0x01, 0x00, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03,
446 0x00, 0x06, 0x19, 0x00, (byte) 0x95, 0x01, (byte) 0x90, 0x58}; //node nlri};
447
448 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
449 buffer.writeBytes(updateMsg);
450
451 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
452 BgpMessage message;
453 BgpHeader bgpHeader = new BgpHeader();
454
455 message = reader.readFrom(buffer, bgpHeader);
456
457 assertThat(message, instanceOf(BgpUpdateMsg.class));
458 }
459
460 /**
461 * In this test case, Invalid MP reach flags is given as input and expecting
462 * an exception.
463 */
464 @Test(expected = BgpParseException.class)
465 public void bgpUpdateMessageTest14() throws BgpParseException {
466 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
467 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
468 (byte) 0xff, (byte) 0xff, 0x00, 0x60, 0x02, 0x00, 0x00, //withdrawn len
469 0x00, 0x49, //path attribute len
470 (byte) 0xff, 0x01, 0x01, 0x00, //origin
471 0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd, (byte) 0xe9, //as_path
472 (byte) 0x80, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, //med
473 (byte) 0xff, 0x0e, 0x34, 0x40, 0x04, 0x47, //mpreach with safi = 71
474 0x04, 0x04, 0x00, 0x00, 0x01, //nexthop
475 0x00, //reserved
476 0x00, 0x01, 0x00,
477 0x27, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x1a, 0x02, 0x00,
478 0x00, 0x04, 0x00, 0x00, 0x08, (byte) 0xae, 0x02, 0x01, 0x00, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03,
479 0x00, 0x06, 0x19, 0x00, (byte) 0x95, 0x01, (byte) 0x90, 0x58}; //node nlri};
480
481 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
482 buffer.writeBytes(updateMsg);
483
484 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
485 BgpMessage message;
486 BgpHeader bgpHeader = new BgpHeader();
487
488 message = reader.readFrom(buffer, bgpHeader);
489
490 assertThat(message, instanceOf(BgpUpdateMsg.class));
491 }
492
493 /**
494 * In this test case, Invalid SAFI is given as input and expecting
495 * an exception.
496 */
497 @Test(expected = BgpParseException.class)
498 public void bgpUpdateMessageTest15() throws BgpParseException {
499 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
500 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
501 (byte) 0xff, (byte) 0xff, 0x00, 0x60, 0x02, 0x00, 0x00, //withdrawn len
502 0x00, 0x49, //path attribute len
503 (byte) 0xff, 0x01, 0x01, 0x00, //origin
504 0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd, (byte) 0xe9, //as_path
505 (byte) 0x80, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, //med
506 (byte) 0x80, 0x0e, 0x34, 0x40, 0x04, 0x49, //mpreach with safi = 71
507 0x04, 0x04, 0x00, 0x00, 0x01, //nexthop
508 0x00, //reserved
509 0x00, 0x01, 0x00,
510 0x27, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x1a, 0x02, 0x00,
511 0x00, 0x04, 0x00, 0x00, 0x08, (byte) 0xae, 0x02, 0x01, 0x00, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03,
512 0x00, 0x06, 0x19, 0x00, (byte) 0x95, 0x01, (byte) 0x90, 0x58}; //node nlri};
513
514 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
515 buffer.writeBytes(updateMsg);
516
517 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
518 BgpMessage message;
519 BgpHeader bgpHeader = new BgpHeader();
520
521 message = reader.readFrom(buffer, bgpHeader);
522
523 assertThat(message, instanceOf(BgpUpdateMsg.class));
524 }
525
526 /**
527 * In this test case, Invalid AFI is given as input and expecting
528 * an exception.
529 */
530 @Test(expected = BgpParseException.class)
531 public void bgpUpdateMessageTest16() throws BgpParseException {
532 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
533 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
534 (byte) 0xff, (byte) 0xff, 0x00, 0x60, 0x02, 0x00, 0x00, //withdrawn len
535 0x00, 0x49, //path attribute len
536 (byte) 0xff, 0x01, 0x01, 0x00, //origin
537 0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd, (byte) 0xe9, //as_path
538 (byte) 0x80, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, //med
539 (byte) 0x80, 0x0e, 0x34, 0x40, 0x06, 0x47, //mpreach with safi = 71
540 0x04, 0x04, 0x00, 0x00, 0x01, //nexthop
541 0x00, //reserved
542 0x00, 0x01, 0x00,
543 0x27, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x1a, 0x02, 0x00,
544 0x00, 0x04, 0x00, 0x00, 0x08, (byte) 0xae, 0x02, 0x01, 0x00, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03,
545 0x00, 0x06, 0x19, 0x00, (byte) 0x95, 0x01, (byte) 0x90, 0x58}; //node nlri};
546
547 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
548 buffer.writeBytes(updateMsg);
549
550 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
551 BgpMessage message;
552 BgpHeader bgpHeader = new BgpHeader();
553
554 message = reader.readFrom(buffer, bgpHeader);
555
556 assertThat(message, instanceOf(BgpUpdateMsg.class));
557 }
558
559 /**
560 * In this test case, Invalid res is given as input and expecting
561 * an exception.
562 */
563 @Test(expected = BgpParseException.class)
564 public void bgpUpdateMessageTest17() throws BgpParseException {
565 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
566 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
567 (byte) 0xff, (byte) 0xff, 0x00, 0x60, 0x02, 0x00, 0x00, //withdrawn len
568 0x00, 0x49, //path attribute len
569 (byte) 0xff, 0x01, 0x01, 0x00, //origin
570 0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd, (byte) 0xe9, //as_path
571 (byte) 0x80, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, //med
572 (byte) 0x80, 0x0e, 0x34, 0x40, 0x04, 0x47, //mpreach with safi = 71
573 0x04, 0x04, 0x00, 0x00, 0x01, //nexthop
574 0x01, //reserved
575 0x00, 0x01, 0x00,
576 0x27, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x1a, 0x02, 0x00,
577 0x00, 0x04, 0x00, 0x00, 0x08, (byte) 0xae, 0x02, 0x01, 0x00, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03,
578 0x00, 0x06, 0x19, 0x00, (byte) 0x95, 0x01, (byte) 0x90, 0x58}; //node nlri};
579
580 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
581 buffer.writeBytes(updateMsg);
582
583 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
584 BgpMessage message;
585 BgpHeader bgpHeader = new BgpHeader();
586
587 message = reader.readFrom(buffer, bgpHeader);
588
589 assertThat(message, instanceOf(BgpUpdateMsg.class));
590 }
591
592 /**
593 * This test case checks update message with node NLRI.
594 */
595 @Test
596 public void bgpUpdateMessageTest18() throws BgpParseException {
597 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
598 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
599 (byte) 0xff, (byte) 0xff, 0x00, 0x60, 0x02, 0x00, 0x00, //withdrawn len
600 0x00, 0x49, //path attribute len
601 0x04, 0x01, 0x01, 0x00, //origin
602 0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd, (byte) 0xe9, //as_path
603 (byte) 0x80, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, //med
604 (byte) 0x80, 0x0e, 0x34, 0x40, 0x04, 0x47, //mpreach with safi = 71
605 0x04, 0x04, 0x00, 0x00, 0x01, //nexthop
606 0x00, //reserved
607 0x00, 0x01, 0x00,
608 0x27, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x1a, 0x02, 0x00,
609 0x00, 0x04, 0x00, 0x00, 0x08, (byte) 0xae, 0x02, 0x01, 0x00, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03,
610 0x00, 0x06, 0x19, 0x00, (byte) 0x95, 0x01, (byte) 0x90, 0x58}; //node nlri
611
612 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
613 buffer.writeBytes(updateMsg);
614
615 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
616 BgpMessage message;
617 BgpHeader bgpHeader = new BgpHeader();
618
619 message = reader.readFrom(buffer, bgpHeader);
620 assertThat(message, instanceOf(BgpUpdateMsg.class));
621 BgpUpdateMsg other = (BgpUpdateMsg) message;
622
623 assertThat(other.getHeader().getMarker(), is(MARKER));
624 assertThat(other.getHeader().getType(), is(UPDATE_MSG_TYPE));
625 assertThat(other.getHeader().getLength(), is((short) 96));
626
627 BgpValueType testPathAttribute;
628 Origin origin;
629 AsPath asPath;
630 Med med;
631 MpReachNlri mpReach;
632 List<BgpValueType> pathAttributes = new LinkedList<>();
633 BgpPathAttributes actualpathAttribute = other.bgpPathAttributes();
634 pathAttributes = actualpathAttribute.pathAttributes();
635 ListIterator<BgpValueType> listIterator = pathAttributes.listIterator();
636 ORIGINTYPE originValue = org.onosproject.bgpio.types.Origin.ORIGINTYPE.IGP;
637
638 testPathAttribute = listIterator.next();
639 origin = (Origin) testPathAttribute;
640 assertThat(origin.origin(), is(originValue));
641
642 testPathAttribute = listIterator.next();
643 asPath = (AsPath) testPathAttribute;
644 ListIterator<Short> listIterator2 = asPath.asPathSeq().listIterator();
645 assertThat(listIterator2.next(), is((short) 65001));
646
647 testPathAttribute = listIterator.next();
648 med = (Med) testPathAttribute;
649 assertThat(med.med(), is(0));
650
651 testPathAttribute = listIterator.next();
652 mpReach = (MpReachNlri) testPathAttribute;
653 assertThat(mpReach.mpReachNlriLen(), is((int) 52));
654 assertThat(mpReach.getType(), is((short) 14));
655
656 List<BgpLSNlri> testMpReachNlri = new LinkedList<>();
657 testMpReachNlri = mpReach.mpReachNlri();
658
659 ListIterator<BgpLSNlri> list1 = testMpReachNlri.listIterator();
660 BgpLSNlri testnlri = list1.next();
661 NlriType nlriType = org.onosproject.bgpio.protocol.NlriType.NODE;
662 ProtocolType protocolId = org.onosproject.bgpio.protocol.linkstate.
663 BgpNodeLSNlriVer4.ProtocolType.ISIS_LEVEL_TWO;
664 assertThat(testnlri.getIdentifier(), is((long) 0));
665 assertThat(testnlri.getNlriType(), is(nlriType));
666 assertThat(testnlri.getProtocolId(), is(protocolId));
667
668 BgpNodeLSNlriVer4 testNodenlri = (BgpNodeLSNlriVer4) testnlri;
669
670 BgpNodeLSIdentifier testLocalNodeDescriptors = testNodenlri.getLocalNodeDescriptors();
671
672 List<BgpValueType> testSubTlvs = new LinkedList<>();
673 NodeDescriptors localNodeDescriptors = testLocalNodeDescriptors.getNodedescriptors();
674 testSubTlvs = localNodeDescriptors.getSubTlvs();
675 ListIterator<BgpValueType> subtlvlist1 = testSubTlvs.listIterator();
676
677 AutonomousSystemTlv testAutonomousSystemTlv = (AutonomousSystemTlv) subtlvlist1.next();
678 assertThat(testAutonomousSystemTlv.getAsNum(), is(2222));
679 assertThat(testAutonomousSystemTlv.getType(), is((short) 512));
680
681 BgpLSIdentifierTlv testBGPLSIdentifierTlv = (BgpLSIdentifierTlv) subtlvlist1.next();
682 assertThat(testBGPLSIdentifierTlv.getBgpLsIdentifier(), is(33686018));
683 assertThat(testBGPLSIdentifierTlv.getType(), is((short) 513));
684
685 IsIsNonPseudonode testIsIsNonPseudonode = (IsIsNonPseudonode) subtlvlist1.next();
686 byte[] expISONodeID = new byte[] {0x19, 0x00, (byte) 0x95, 0x01, (byte) 0x90, 0x58};
687 assertThat(testIsIsNonPseudonode.getISONodeID(), is(expISONodeID));
688 assertThat(testIsIsNonPseudonode.getType(), is((short) 515));
689
690 }
691
692 /**
693 * This test case checks update message with prefix NLRI.
694 */
695 @Test
696 public void bgpUpdateMessageTest19() throws BgpParseException {
697 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
698 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
699 (byte) 0xff, (byte) 0xff, 0x00, (byte) 0xd6, 0x02, 0x00, 0x04,
700 0x18, 0x0a, 0x01, 0x01, //withdrawn routes
701 0x00, (byte) 0xbb, //path attribute len
702 0x04, 0x01, 0x01, 0x00, //origin
703 0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd, (byte) 0xe9, //as_path
704 (byte) 0x80, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, //med
705 (byte) 0x90, 0x0e, 0x00, (byte) 0xa5, 0x40, 0x04, 0x47, //mpreach
706 0x04, 0x04, 0x00, 0x00, 0x01, //nexthop
707 0x00, //reserved
708 0x00, 0x03, 0x00, 0x30, 0x02, 0x00, 0x00, 0x00,
709 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
710 0x1a, 0x02, 0x00, 0x00, 0x04, 0x00, 0x00, 0x08,
711 (byte) 0xae, 0x02, 0x01, 0x00, 0x04, 0x02, 0x02, 0x02,
712 0x02, 0x02, 0x03, 0x00, 0x06, 0x19, 0x21, 0x68,
713 0x07, 0x70, 0x01, 0x01, 0x09, 0x00, 0x05, 0x20,
714 (byte) 0xc0, (byte) 0xa8, 0x4d, 0x01, 0x00, 0x03, 0x00, 0x30,
715 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
716 0x00, 0x01, 0x00, 0x00, 0x1a, 0x02, 0x00, 0x00,
717 0x04, 0x00, 0x00, 0x08, (byte) 0xae, 0x02, 0x01, 0x00,
718 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x00,
719 0x06, 0x19, 0x00, (byte) 0x95, 0x02, 0x50, 0x21, 0x01,
720 0x09, 0x00, 0x05, 0x20, 0x15, 0x15, 0x15, 0x15,
721 0x00, 0x03, 0x00, 0x30, 0x02, 0x00, 0x00, 0x00,
722 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
723 0x1a, 0x02, 0x00, 0x00, 0x04, 0x00, 0x00, 0x08,
724 (byte) 0xae, 0x02, 0x01, 0x00, 0x04, 0x02, 0x02, 0x02,
725 0x02, 0x02, 0x03, 0x00, 0x06, 0x02, 0x20, 0x22,
726 0x02, 0x20, 0x22, 0x01, 0x09, 0x00, 0x05, 0x20,
727 0x16, 0x16, 0x16, 0x16}; // prefix nlri
728
729 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
730 buffer.writeBytes(updateMsg);
731
732 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
733 BgpMessage message;
734 BgpHeader bgpHeader = new BgpHeader();
735
736 message = reader.readFrom(buffer, bgpHeader);
737 assertThat(message, instanceOf(BgpUpdateMsg.class));
738 BgpUpdateMsg other = (BgpUpdateMsg) message;
739
740 assertThat(other.getHeader().getMarker(), is(MARKER));
741 assertThat(other.getHeader().getType(), is(UPDATE_MSG_TYPE));
742 assertThat(other.getHeader().getLength(), is((short) 214));
743
744 ListIterator<IpPrefix> listIterator1 = other.withdrawnRoutes().listIterator();
745 byte[] prefix = new byte[] {0x0a, 0x01, 0x01, 0x00};
746
747 IpPrefix testPrefixValue = listIterator1.next();
748 assertThat(testPrefixValue.prefixLength(), is((int) 24));
749 assertThat(testPrefixValue.address().toOctets(), is(prefix));
750
751 BgpValueType testPathAttribute;
752 Origin origin;
753 AsPath asPath;
754 Med med;
755 MpReachNlri mpReach;
756 List<BgpValueType> pathAttributes = new LinkedList<>();
757 BgpPathAttributes actualpathAttribute = other.bgpPathAttributes();
758 pathAttributes = actualpathAttribute.pathAttributes();
759 ListIterator<BgpValueType> listIterator = pathAttributes.listIterator();
760 ORIGINTYPE originValue = org.onosproject.bgpio.types.Origin.ORIGINTYPE.IGP;
761
762 testPathAttribute = listIterator.next();
763 origin = (Origin) testPathAttribute;
764 assertThat(origin.origin(), is(originValue));
765
766 testPathAttribute = listIterator.next();
767 asPath = (AsPath) testPathAttribute;
768 ListIterator<Short> listIterator2 = asPath.asPathSeq().listIterator();
769 assertThat(listIterator2.next(), is((short) 65001));
770
771 testPathAttribute = listIterator.next();
772 med = (Med) testPathAttribute;
773 assertThat(med.med(), is(0));
774
775 testPathAttribute = listIterator.next();
776 mpReach = (MpReachNlri) testPathAttribute;
777 assertThat(mpReach.mpReachNlriLen(), is((int) 165));
778 assertThat(mpReach.getType(), is((short) 14));
779
780 List<BgpLSNlri> testMpReachNlri = new LinkedList<>();
781 testMpReachNlri = mpReach.mpReachNlri();
782
783 ListIterator<BgpLSNlri> list1 = testMpReachNlri.listIterator();
784 BgpLSNlri testnlri = list1.next();
785 NlriType nlriType = org.onosproject.bgpio.protocol.NlriType.PREFIX_IPV4;
786 ProtocolType protocolId = org.onosproject.bgpio.protocol.linkstate.
787 BgpNodeLSNlriVer4.ProtocolType.ISIS_LEVEL_TWO;
788 assertThat(testnlri.getIdentifier(), is((long) 0));
789 assertThat(testnlri.getNlriType(), is(nlriType));
790 assertThat(testnlri.getProtocolId(), is(protocolId));
791
792 BgpPrefixLSNlri testprefixnlri = (BgpPrefixLSNlri) testnlri;
793
794 NodeDescriptors testLocalNodeDescriptors = testprefixnlri.getLocalNodeDescriptors();
795
796 List<BgpValueType> testSubTlvs = new LinkedList<>();
797 testSubTlvs = testLocalNodeDescriptors.getSubTlvs();
798 ListIterator<BgpValueType> subtlvlist1 = testSubTlvs.listIterator();
799
800 AutonomousSystemTlv testAutonomousSystemTlv = (AutonomousSystemTlv) subtlvlist1.next();
801 assertThat(testAutonomousSystemTlv.getAsNum(), is(2222));
802 assertThat(testAutonomousSystemTlv.getType(), is((short) 512));
803
804 BgpLSIdentifierTlv testBGPLSIdentifierTlv = (BgpLSIdentifierTlv) subtlvlist1.next();
805 assertThat(testBGPLSIdentifierTlv.getBgpLsIdentifier(), is(33686018));
806 assertThat(testBGPLSIdentifierTlv.getType(), is((short) 513));
807
808 IsIsNonPseudonode testIsIsNonPseudonode = (IsIsNonPseudonode) subtlvlist1.next();
809 byte[] expISONodeID = new byte[] {0x19, 0x21, 0x68, 0x07, 0x70, 0x01};
810 assertThat(testIsIsNonPseudonode.getISONodeID(), is(expISONodeID));
811 assertThat(testIsIsNonPseudonode.getType(), is((short) 515));
812
813 List<BgpValueType> testPrefixDescriptors = new LinkedList<>();
814 testPrefixDescriptors = testprefixnlri.getPrefixdescriptor();
815 ListIterator<BgpValueType> subtlvlist2 = testPrefixDescriptors.listIterator();
816 IPReachabilityInformationTlv testIPReachabilityInformationTlv = (IPReachabilityInformationTlv)
817 subtlvlist2.next();
818 byte[] address = new byte[] {(byte) 0xc0, (byte) 0xa8, 0x4d, 0x01};
819 IpPrefix prefix1 = IpPrefix.valueOf(IpAddress.Version.INET, address, 32);
820 assertThat(testIPReachabilityInformationTlv.getPrefixValue(), is(prefix1));
821 assertThat(testIPReachabilityInformationTlv.getPrefixLen(), is((byte) 32));
822 }
823
824 /**
825 * This test case checks update message with link NLRI.
826 */
827 @Test
828 public void bgpUpdateMessageTest20() throws BgpParseException {
829 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
830 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
831 (byte) 0xff, (byte) 0xff, 0x00, (byte) 0x83, 0x02, 0x00, 0x04,
832 0x18, 0x0a, 0x01, 0x01, //withdrawn routes
833 0x00, 0x68, //path attribute len
834 0x04, 0x01, 0x01, 0x00, //origin
835 0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd, (byte) 0xe9, //as_path
836 (byte) 0x80, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, //med
837 (byte) 0x80, 0x0e, 0x53, 0x40, 0x04, 0x47, //mpreach
838 0x04, 0x04, 0x00, 0x00, 0x01, //nexthop
839 0x00, //reserved
840 0x00, 0x02, 0x00, 0x46, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
841 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x1b, 0x02, 0x00, 0x00,
842 0x04, 0x00, 0x00, 0x08, (byte) 0xae, 0x02, 0x01, 0x00, 0x04,
843 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x00, 0x07, 0x19, 0x00,
844 (byte) 0x95, 0x02, 0x50, 0x21, 0x03, 0x01, 0x01, 0x00, 0x1a, 0x02,
845 0x00, 0x00, 0x04, 0x00, 0x00, 0x08, (byte) 0xae, 0x02, 0x01, 0x00,
846 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x00, 0x06, 0x19,
847 0x00, (byte) 0x95, 0x02, 0x50, 0x21//link nlri
848 };
849
850 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
851 buffer.writeBytes(updateMsg);
852
853 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
854 BgpMessage message = null;
855 BgpHeader bgpHeader = new BgpHeader();
856
857 message = reader.readFrom(buffer, bgpHeader);
858 assertThat(message, instanceOf(BgpUpdateMsg.class));
859 BgpUpdateMsg other = (BgpUpdateMsg) message;
860
861 assertThat(other.getHeader().getMarker(), is(MARKER));
862 assertThat(other.getHeader().getType(), is(UPDATE_MSG_TYPE));
863 assertThat(other.getHeader().getLength(), is((short) 131));
864
865 ListIterator<IpPrefix> listIterator1 = other.withdrawnRoutes().listIterator();
866 byte[] prefix = new byte[] {0x0a, 0x01, 0x01, 0x00};
867
868 IpPrefix testPrefixValue = listIterator1.next();
869 assertThat(testPrefixValue.prefixLength(), is((int) 24));
870 assertThat(testPrefixValue.address().toOctets(), is(prefix));
871
872 BgpValueType testPathAttribute;
873 Origin origin;
874 AsPath asPath;
875 Med med;
876 MpReachNlri mpReach;
877
878 List<BgpValueType> pathAttributes = new LinkedList<>();
879 BgpPathAttributes actualpathAttribute = other.bgpPathAttributes();
880 pathAttributes = actualpathAttribute.pathAttributes();
881 ListIterator<BgpValueType> listIterator = pathAttributes.listIterator();
882 ORIGINTYPE originValue = org.onosproject.bgpio.types.Origin.ORIGINTYPE.IGP;
883
884 testPathAttribute = listIterator.next();
885 origin = (Origin) testPathAttribute;
886 assertThat(origin.origin(), is(originValue));
887
888 testPathAttribute = listIterator.next();
889 asPath = (AsPath) testPathAttribute;
890 ListIterator<Short> listIterator2 = asPath.asPathSeq().listIterator();
891 assertThat(listIterator2.next(), is((short) 65001));
892
893 testPathAttribute = listIterator.next();
894 med = (Med) testPathAttribute;
895 assertThat(med.med(), is(0));
896
897 testPathAttribute = listIterator.next();
898 mpReach = (MpReachNlri) testPathAttribute;
899 assertThat(mpReach.mpReachNlriLen(), is((int) 83));
900 assertThat(mpReach.getType(), is((short) 14));
901
902 List<BgpLSNlri> testMpReachNlri = new LinkedList<>();
903 testMpReachNlri = mpReach.mpReachNlri();
904
905 ListIterator<BgpLSNlri> list1 = testMpReachNlri.listIterator();
906 BgpLSNlri testnlri = list1.next();
907 NlriType nlriType = org.onosproject.bgpio.protocol.NlriType.LINK;
908 ProtocolType protocolId = org.onosproject.bgpio.protocol.linkstate.
909 BgpNodeLSNlriVer4.ProtocolType.ISIS_LEVEL_TWO;
910 assertThat(testnlri.getIdentifier(), is((long) 0));
911 assertThat(testnlri.getNlriType(), is(nlriType));
912 assertThat(testnlri.getProtocolId(), is(protocolId));
913
914 BgpLinkLsNlriVer4 testlinknlri = (BgpLinkLsNlriVer4) testnlri;
915
916 NodeDescriptors testLocalNodeDescriptors = testlinknlri.localNodeDescriptors();
917
918 List<BgpValueType> testSubTlvs = new LinkedList<>();
919 testSubTlvs = testLocalNodeDescriptors.getSubTlvs();
920 ListIterator<BgpValueType> subtlvlist1 = testSubTlvs.listIterator();
921
922 AutonomousSystemTlv testAutonomousSystemTlv = (AutonomousSystemTlv) subtlvlist1.next();
923
924 assertThat(testAutonomousSystemTlv.getAsNum(), is(2222));
925 assertThat(testAutonomousSystemTlv.getType(), is((short) 512));
926
927 BgpLSIdentifierTlv testBGPLSIdentifierTlv = (BgpLSIdentifierTlv) subtlvlist1.next();
928 assertThat(testBGPLSIdentifierTlv.getBgpLsIdentifier(), is(33686018));
929 assertThat(testBGPLSIdentifierTlv.getType(), is((short) 513));
930
931 IsIsPseudonode testIsIsPseudonode = (IsIsPseudonode) subtlvlist1.next();
932 assertThat(testIsIsPseudonode.getPSNIdentifier(), is((byte) 3));
933 assertThat(testIsIsPseudonode.getType(), is((short) 515));
934
935 NodeDescriptors testRemoteNodeDescriptors = testlinknlri.remoteNodeDescriptors();
936 testSubTlvs = testRemoteNodeDescriptors.getSubTlvs();
937 ListIterator<BgpValueType> subtlvlist2 = testSubTlvs.listIterator();
938
939 testAutonomousSystemTlv = (AutonomousSystemTlv) subtlvlist2.next();
940
941 assertThat(testAutonomousSystemTlv.getAsNum(), is(2222));
942 assertThat(testAutonomousSystemTlv.getType(), is((short) 512));
943
944 testBGPLSIdentifierTlv = (BgpLSIdentifierTlv) subtlvlist2.next();
945 assertThat(testBGPLSIdentifierTlv.getBgpLsIdentifier(), is(33686018));
946 assertThat(testBGPLSIdentifierTlv.getType(), is((short) 513));
947
948 IsIsNonPseudonode testIsIsNonPseudonode = (IsIsNonPseudonode) subtlvlist2.next();
949 byte[] expISONodeID = new byte[] {0x19, 0x00, (byte) 0x95, 0x02, 0x50, 0x21};
950 assertThat(testIsIsNonPseudonode.getISONodeID(), is(expISONodeID));
951 assertThat(testIsIsNonPseudonode.getType(), is((short) 515));
952 }
953
954 /**
955 * In this test case, Invalid withdrawn route length is given as input and expecting
956 * an exception.
957 */
958 @Test(expected = BgpParseException.class)
959 public void bgpUpdateMessageTest21() throws BgpParseException {
960 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
961 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
962 (byte) 0xff, (byte) 0xff, 0x00, 0x1b, 0x02, 0x00, 0x07, 0x18, 0x0a, 0x01, 0x01, 0x00, 0x00};
963
964 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
965 buffer.writeBytes(updateMsg);
966
967 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
968 BgpMessage message;
969 BgpHeader bgpHeader = new BgpHeader();
970
971 message = reader.readFrom(buffer, bgpHeader);
972 assertThat(message, instanceOf(BgpUpdateMsg.class));
973 }
974
975 /**
976 * In this test case, Invalid withdrawn route length is given as input and expecting
977 * an exception.
978 */
979 @Test(expected = BgpParseException.class)
980 public void bgpUpdateMessageTest22() throws BgpParseException {
981 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
982 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
983 (byte) 0xff, (byte) 0xff, 0x00, 0x25, 0x02, 0x00, 0x00, //withdrawn len
984 0x00, 0x0e, //path attribute len
985 0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd, (byte) 0xe9, //as_path
986 (byte) 0x80, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00}; //med
987
988 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
989 buffer.writeBytes(updateMsg);
990
991 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
992 BgpMessage message;
993 BgpHeader bgpHeader = new BgpHeader();
994
995 message = reader.readFrom(buffer, bgpHeader);
996
997 assertThat(message, instanceOf(BgpUpdateMsg.class));
998 }
999
1000 /**
1001 * In this test case, Mandatory attributes are not given in input and expecting
1002 * an exception.
1003 */
1004 @Test(expected = BgpParseException.class)
1005 public void bgpUpdateMessageTest23() throws BgpParseException {
1006 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1007 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1008 (byte) 0xff, (byte) 0xff, 0x00, 0x29, 0x02, 0x00, 0x00, //withdrawn len
1009 0x00, 0x12, //path attribute len
1010 0x0e, 0x01, 0x01, 0x00, //origin
1011 0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd, (byte) 0xe9, //as_path
1012 (byte) 0x80, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00}; //med
1013
1014 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
1015 buffer.writeBytes(updateMsg);
1016
1017 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
1018 BgpMessage message;
1019 BgpHeader bgpHeader = new BgpHeader();
1020
1021 message = reader.readFrom(buffer, bgpHeader);
1022
1023 assertThat(message, instanceOf(BgpUpdateMsg.class));
1024 }
1025
1026 /**
1027 * In this test case, Invalid origin length is given as input and expecting
1028 * an exception.
1029 */
1030 @Test(expected = BgpParseException.class)
1031 public void bgpUpdateMessageTest24() throws BgpParseException {
1032 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1033 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1034 (byte) 0xff, (byte) 0xff, 0x00, 0x29, 0x02, 0x00, 0x00, //withdrawn len
1035 0x00, 0x12, //path attribute len
1036 0x04, 0x01, 0x02, 0x00, //origin
1037 0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd, (byte) 0xe9, //as_path
1038 (byte) 0x80, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00}; //med
1039
1040 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
1041 buffer.writeBytes(updateMsg);
1042
1043 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
1044 BgpMessage message;
1045 BgpHeader bgpHeader = new BgpHeader();
1046
1047 message = reader.readFrom(buffer, bgpHeader);
1048
1049 assertThat(message, instanceOf(BgpUpdateMsg.class));
1050 }
1051
1052 /**
1053 * In this test case, Invalid origin value is given as input and expecting
1054 * an exception.
1055 */
1056 @Test(expected = BgpParseException.class)
1057 public void bgpUpdateMessageTest25() throws BgpParseException {
1058 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1059 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1060 (byte) 0xff, (byte) 0xff, 0x00, 0x29, 0x02, 0x00, 0x00, //withdrawn len
1061 0x00, 0x12, //path attribute len
1062 0x04, 0x01, 0x01, 0x04, //origin
1063 0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd, (byte) 0xe9, //as_path
1064 (byte) 0x80, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00}; //med
1065
1066 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
1067 buffer.writeBytes(updateMsg);
1068
1069 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
1070 BgpMessage message;
1071 BgpHeader bgpHeader = new BgpHeader();
1072
1073 message = reader.readFrom(buffer, bgpHeader);
1074
1075 assertThat(message, instanceOf(BgpUpdateMsg.class));
1076 }
1077
1078 /**
1079 * In this test case, Invalid descriptor type in node nlri is given as input and expecting
1080 * an exception.
1081 */
1082 @Test(expected = BgpParseException.class)
1083 public void bgpUpdateMessageTest26() throws BgpParseException {
1084 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1085 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1086 (byte) 0xff, (byte) 0xff, 0x00, 0x60, 0x02, 0x00, 0x00, //withdrawn len
1087 0x00, 0x49, //path attribute len
1088 0x04, 0x01, 0x01, 0x00, //origin
1089 0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd, (byte) 0xe9, //as_path
1090 (byte) 0x80, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, //med
1091 (byte) 0x80, 0x0e, 0x34, 0x40, 0x04, 0x47, //mpreach with safi = 71
1092 0x04, 0x04, 0x00, 0x00, 0x01, //nexthop
1093 0x00, //reserved
1094 0x00, 0x01, 0x00,
1095 0x27, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x1a, 0x02, 0x00,
1096 0x00, 0x04, 0x00, 0x00, 0x08, (byte) 0xae, 0x02, 0x01, 0x00, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03,
1097 0x00, 0x06, 0x19, 0x00, (byte) 0x95, 0x01, (byte) 0x90, 0x58}; //node nlri
1098
1099 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
1100 buffer.writeBytes(updateMsg);
1101
1102 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
1103 BgpMessage message;
1104 BgpHeader bgpHeader = new BgpHeader();
1105
1106 message = reader.readFrom(buffer, bgpHeader);
1107
1108 assertThat(message, instanceOf(BgpUpdateMsg.class));
1109 }
1110
1111 /**
1112 * In this test case, Invalid node nlri length field in is given as input and expecting
1113 * an exception.
1114 */
1115 @Test(expected = BgpParseException.class)
1116 public void bgpUpdateMessageTest27() throws BgpParseException {
1117 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1118 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1119 (byte) 0xff, (byte) 0xff, 0x00, 0x60, 0x02, 0x00, 0x00, //withdrawn len
1120 0x00, 0x49, //path attribute len
1121 0x04, 0x01, 0x01, 0x00, //origin
1122 0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd, (byte) 0xe9, //as_path
1123 (byte) 0x80, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, //med
1124 (byte) 0x80, 0x0e, 0x34, 0x40, 0x04, 0x47, //mpreach with safi = 71
1125 0x04, 0x04, 0x00, 0x00, 0x01, //nexthop
1126 0x00, //reserved
1127 0x00, 0x01, 0x00,
1128 0x27, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x1b, 0x02, 0x00,
1129 0x00, 0x04, 0x00, 0x00, 0x08, (byte) 0xae, 0x02, 0x01, 0x00, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03,
1130 0x00, 0x06, 0x19, 0x00, (byte) 0x95, 0x01, (byte) 0x90, 0x58}; //node nlri
1131
1132 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
1133 buffer.writeBytes(updateMsg);
1134
1135 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
1136 BgpMessage message;
1137 BgpHeader bgpHeader = new BgpHeader();
1138
1139 message = reader.readFrom(buffer, bgpHeader);
1140
1141 assertThat(message, instanceOf(BgpUpdateMsg.class));
1142 }
1143
1144 /**
1145 * In this test case, withdrawn routes with prefix length 0 is given as input and expecting
1146 * an exception.
1147 */
1148 @Test
1149 public void bgpUpdateMessageTest28() throws BgpParseException {
1150 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1151 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1152 (byte) 0xff, (byte) 0xff, //marker
1153 0x00, 0x18, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00};
1154
1155 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
1156 buffer.writeBytes(updateMsg);
1157
1158 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
1159 BgpMessage message;
1160 BgpHeader bgpHeader = new BgpHeader();
1161
1162 message = reader.readFrom(buffer, bgpHeader);
1163
1164 assertThat(message, instanceOf(BgpUpdateMsg.class));
1165 }
1166
1167 /**
1168 * In this test case, update message without total Path Attribute Length field is given as
1169 * input and expecting an exception.
1170 */
1171 @Test(expected = BgpParseException.class)
1172 public void bgpUpdateMessageTest29() throws BgpParseException {
1173 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1174 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1175 (byte) 0xff, (byte) 0xff, //marker
1176 0x00, 0x16, 0x02, 0x00, 0x01, 0x00};
1177
1178 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
1179 buffer.writeBytes(updateMsg);
1180
1181 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
1182 BgpMessage message;
1183 BgpHeader bgpHeader = new BgpHeader();
1184
1185 message = reader.readFrom(buffer, bgpHeader);
1186
1187 assertThat(message, instanceOf(BgpUpdateMsg.class));
1188 }
1189
1190 /**
1191 * This test case checks update message with as4 path attribute.
1192 */
1193 @Test
1194 public void bgpUpdateMessageTest30() throws BgpParseException {
1195 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1196 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1197 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1198 0x00, 0x3a, 0x02, 0x00, 0x00, 0x00, 0x21, 0x40, 0x01, 0x01, 0x00, (byte) 0xc0,
1199 0x11, 0x0a, 0x02, 0x02, 0x00, 0x0a, 0x00, 0x01, 0x00, 0x28, 0x00, 0x01, 0x40,
1200 0x02, 0x06, 0x02, 0x02, 0x5b, (byte) 0xa0, 0x5b, (byte) 0xa0, 0x40, 0x03, 0x04,
1201 (byte) 0xac, 0x10, 0x03, 0x01, 0x08, 0x28};
1202
1203 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
1204 buffer.writeBytes(updateMsg);
1205
1206 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
1207 BgpMessage message = null;
1208 BgpHeader bgpHeader = new BgpHeader();
1209
1210 message = reader.readFrom(buffer, bgpHeader);
1211 assertThat(message, instanceOf(BgpUpdateMsg.class));
1212 BgpUpdateMsg other = (BgpUpdateMsg) message;
1213
1214 assertThat(other.getHeader().getMarker(), is(MARKER));
1215 assertThat(other.getHeader().getType(), is(UPDATE_MSG_TYPE));
1216 assertThat(other.getHeader().getLength(), is((short) 58));
1217
1218 BgpValueType testPathAttribute;
1219 Origin origin;
1220 As4Path as4Path;
1221 AsPath asPath;
1222 NextHop nextHop;
1223
1224 List<BgpValueType> pathAttributes = new LinkedList<>();
1225 BgpPathAttributes actualpathAttribute = other.bgpPathAttributes();
1226 pathAttributes = actualpathAttribute.pathAttributes();
1227 ListIterator<BgpValueType> listIterator = pathAttributes.listIterator();
1228 ORIGINTYPE originValue = org.onosproject.bgpio.types.Origin.ORIGINTYPE.IGP;
1229
1230 testPathAttribute = listIterator.next();
1231 origin = (Origin) testPathAttribute;
1232 assertThat(origin.origin(), is(originValue));
1233
1234 testPathAttribute = listIterator.next();
1235 as4Path = (As4Path) testPathAttribute;
1236 ListIterator<Integer> listIterator2 = as4Path.as4PathSEQ().listIterator();
1237 assertThat(listIterator2.next(), is(655361));
1238
1239 testPathAttribute = listIterator.next();
1240 asPath = (AsPath) testPathAttribute;
1241 ListIterator<Short> listIterator3 = asPath.asPathSeq().listIterator();
1242 assertThat(listIterator3.next(), is((short) 23456));
1243
1244 testPathAttribute = listIterator.next();
1245 nextHop = (NextHop) testPathAttribute;
1246 byte[] nextHopAddr = new byte[] {(byte) 0xac, 0x10, 0x03, 0x01};
1247 assertThat(nextHop.nextHop().toOctets(), is(nextHopAddr));
1248
1249 ListIterator<IpPrefix> listIterator1 = other.nlri().listIterator();
1250 byte[] prefix = new byte[] {0x28, 0x00, 0x00, 0x00};
1251
1252 IpPrefix testPrefixValue = listIterator1.next();
1253 assertThat(testPrefixValue.prefixLength(), is((int) 8));
1254 assertThat(testPrefixValue.address().toOctets(), is(prefix));
1255 }
1256
1257 /**
1258 * This test case checks update message with MPUnreach.
1259 */
1260 @Test
1261 public void bgpUpdateMessageTest31() throws BgpParseException {
1262 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1263 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1264 (byte) 0xff, (byte) 0xff, 0x00, 0x5e, 0x02, 0x00, 0x04, 0x18, 0x0a, 0x01, 0x01, //withdrawn routes
1265 0x00, 0x43, //path attribute len
1266 0x04, 0x01, 0x01, 0x00, //origin
1267 0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd, (byte) 0xe9, //as_path
1268 (byte) 0x80, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, //med
1269 (byte) 0x80, 0x0f, 0x2e, 0x40, 0x04, 0x47, //mpunreach with safi = 71
1270 0x00, 0x01, 0x00,
1271 0x27, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x1a, 0x02, 0x00,
1272 0x00, 0x04, 0x00, 0x00, 0x08, (byte) 0xae, 0x02, 0x01, 0x00, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03,
1273 0x00, 0x06, 0x19, 0x00, (byte) 0x95, 0x01, (byte) 0x90, 0x58}; //node nlri
1274
1275 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
1276 buffer.writeBytes(updateMsg);
1277
1278 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
1279 BgpMessage message;
1280 BgpHeader bgpHeader = new BgpHeader();
1281
1282 message = reader.readFrom(buffer, bgpHeader);
1283 assertThat(message, instanceOf(BgpUpdateMsg.class));
1284 BgpUpdateMsg other = (BgpUpdateMsg) message;
1285
1286 assertThat(other.getHeader().getMarker(), is(MARKER));
1287 assertThat(other.getHeader().getType(), is(UPDATE_MSG_TYPE));
1288 assertThat(other.getHeader().getLength(), is((short) 94));
1289
1290 ListIterator<IpPrefix> listIterator1 = other.withdrawnRoutes().listIterator();
1291 byte[] prefix = new byte[] {0x0a, 0x01, 0x01, 0x00};
1292
1293 IpPrefix testPrefixValue = listIterator1.next();
1294 assertThat(testPrefixValue.prefixLength(), is((int) 24));
1295 assertThat(testPrefixValue.address().toOctets(), is(prefix));
1296
1297 BgpValueType testPathAttribute;
1298 Origin origin;
1299 AsPath asPath;
1300 Med med;
1301 MpUnReachNlri mpUnReach;
1302 List<BgpValueType> pathAttributes = new LinkedList<>();
1303 BgpPathAttributes actualpathAttribute = other.bgpPathAttributes();
1304 pathAttributes = actualpathAttribute.pathAttributes();
1305 ListIterator<BgpValueType> listIterator = pathAttributes.listIterator();
1306 ORIGINTYPE originValue = org.onosproject.bgpio.types.Origin.ORIGINTYPE.IGP;
1307
1308 testPathAttribute = listIterator.next();
1309 origin = (Origin) testPathAttribute;
1310 assertThat(origin.origin(), is(originValue));
1311
1312 testPathAttribute = listIterator.next();
1313 asPath = (AsPath) testPathAttribute;
1314 ListIterator<Short> listIterator2 = asPath.asPathSeq().listIterator();
1315 assertThat(listIterator2.next(), is((short) 65001));
1316
1317 testPathAttribute = listIterator.next();
1318 med = (Med) testPathAttribute;
1319 assertThat(med.med(), is(0));
1320
1321 testPathAttribute = listIterator.next();
1322 mpUnReach = (MpUnReachNlri) testPathAttribute;
1323 assertThat(mpUnReach.mpUnReachNlriLen(), is((int) 46));
1324 assertThat(mpUnReach.getType(), is((short) 15));
1325
1326 List<BgpLSNlri> testMpUnReachNlri = new LinkedList<>();
1327 testMpUnReachNlri = mpUnReach.mpUnReachNlri();
1328
1329 ListIterator<BgpLSNlri> list1 = testMpUnReachNlri.listIterator();
1330 BgpLSNlri testnlri = list1.next();
1331 NlriType nlriType = org.onosproject.bgpio.protocol.NlriType.NODE;
1332 ProtocolType protocolId = org.onosproject.bgpio.protocol.linkstate.
1333 BgpNodeLSNlriVer4.ProtocolType.ISIS_LEVEL_TWO;
1334 assertThat(testnlri.getIdentifier(), is((long) 0));
1335 assertThat(testnlri.getNlriType(), is(nlriType));
1336 assertThat(testnlri.getProtocolId(), is(protocolId));
1337
1338 BgpNodeLSNlriVer4 testNodenlri = (BgpNodeLSNlriVer4) testnlri;
1339
1340 BgpNodeLSIdentifier testLocalNodeDescriptors = testNodenlri.getLocalNodeDescriptors();
1341
1342 List<BgpValueType> testSubTlvs = new LinkedList<>();
1343 NodeDescriptors localNodeDescriptors = testLocalNodeDescriptors.getNodedescriptors();
1344 testSubTlvs = localNodeDescriptors.getSubTlvs();
1345 ListIterator<BgpValueType> subtlvlist1 = testSubTlvs.listIterator();
1346
1347 AutonomousSystemTlv testAutonomousSystemTlv = (AutonomousSystemTlv) subtlvlist1.next();
1348
1349 assertThat(testAutonomousSystemTlv.getAsNum(), is(2222));
1350 assertThat(testAutonomousSystemTlv.getType(), is((short) 512));
1351
1352 BgpLSIdentifierTlv testBGPLSIdentifierTlv = (BgpLSIdentifierTlv) subtlvlist1.next();
1353 assertThat(testBGPLSIdentifierTlv.getBgpLsIdentifier(), is(33686018));
1354 assertThat(testBGPLSIdentifierTlv.getType(), is((short) 513));
1355
1356 IsIsNonPseudonode testIsIsNonPseudonode = (IsIsNonPseudonode) subtlvlist1.next();
1357 byte[] expISONodeID = new byte[] {0x19, 0x00, (byte) 0x95, 0x01, (byte) 0x90, 0x58};
1358 assertThat(testIsIsNonPseudonode.getISONodeID(), is(expISONodeID));
1359 assertThat(testIsIsNonPseudonode.getType(), is((short) 515));
1360 }
1361
1362 /**
1363 * This test case checks update message with invalid mpreach packet.
1364 */
1365 @Test(expected = BgpParseException.class)
1366 public void bgpUpdateMessageTest32() throws BgpParseException {
1367 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1368 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1369 (byte) 0xff, (byte) 0xff, 0x00, (byte) 0xd6, 0x02, 0x00, 0x04,
1370 0x18, 0x0a, 0x01, 0x01, //withdrawn routes
1371 0x00, (byte) 0xbb, //path attribute len
1372 0x04, 0x01, 0x01, 0x00, //origin
1373 0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd, (byte) 0xe9, //as_path
1374 (byte) 0x80, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, //med
1375 (byte) 0x90, 0x0e, 0x00, (byte) 0xa5, 0x40, 0x04, 0x47, //mpreach
1376 0x04, 0x04, 0x00, 0x00, 0x01, //nexthop
1377 0x00, //reserved
1378 0x00, 0x03, 0x00, 0x30, 0x02, 0x00, 0x00, 0x00,
1379 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
1380 0x1a, 0x02, 0x00, 0x00, 0x04, 0x00, 0x00, 0x08,
1381 (byte) 0xae, 0x02, 0x01, 0x00, 0x04, 0x02, 0x02, 0x02,
1382 0x02, 0x02, 0x03, 0x00, 0x06, 0x19, 0x21, 0x68,
1383 0x07, 0x70, 0x01, 0x01, 0x09, 0x00, 0x05, 0x20,
1384 (byte) 0xc0, (byte) 0xa8, 0x4d, 0x01, 0x00, 0x03, 0x00, 0x30,
1385 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1386 0x00, 0x01, 0x00, 0x00, 0x1a, 0x02, 0x00, 0x00,
1387 0x04, 0x00, 0x00, 0x08, (byte) 0xae, 0x02, 0x01, 0x00,
1388 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x00,
1389 0x06, 0x19, 0x00, (byte) 0x95, 0x02, 0x50, 0x21, 0x01,
1390 0x09, 0x00, 0x05, 0x20, 0x15, 0x15, 0x15, 0x15,
1391 0x00, 0x03, 0x00, 0x30, 0x02, 0x00, 0x00, 0x00,
1392 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
1393 0x1a, 0x02, 0x00, 0x00, 0x04, 0x00, 0x00, 0x08,
1394 (byte) 0xae, 0x02, 0x01, 0x00, 0x04, 0x02, 0x02, 0x02,
1395 0x02, 0x02, 0x03, 0x00, 0x06, 0x02, 0x20, 0x22,
1396 0x02, 0x20, 0x22, 0x01, 0x09, 0x00, 0x05, 0x20,
1397 0x16, 0x16, 0x16, 0x16}; // prefix nlri
1398
1399 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
1400 buffer.writeBytes(updateMsg);
1401
1402 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
1403 BgpMessage message;
1404 BgpHeader bgpHeader = new BgpHeader();
1405
1406 message = reader.readFrom(buffer, bgpHeader);
1407
1408 assertThat(message, instanceOf(BgpUpdateMsg.class));
1409 }
1410
1411 /**
1412 * This test case checks update message with invalid prefix nlri length in input.
1413 */
1414 @Test(expected = BgpParseException.class)
1415 public void bgpUpdateMessageTest33() throws BgpParseException {
1416 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1417 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1418 (byte) 0xff, (byte) 0xff, 0x00, (byte) 0xd6, 0x02, 0x00, 0x04,
1419 0x18, 0x0a, 0x01, 0x01, //withdrawn routes
1420 0x00, (byte) 0xbb, //path attribute len
1421 0x04, 0x01, 0x01, 0x00, //origin
1422 0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd, (byte) 0xe9, //as_path
1423 (byte) 0x80, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, //med
1424 (byte) 0x90, 0x0e, 0x00, (byte) 0xa5, 0x40, 0x04, 0x47, //mpreach
1425 0x04, 0x04, 0x00, 0x00, 0x01, //nexthop
1426 0x00, //reserved
1427 0x00, 0x03, 0x00, 0x35, 0x02, 0x00, 0x00, 0x00,
1428 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
1429 0x1a, 0x02, 0x00, 0x00, 0x04, 0x00, 0x00, 0x08,
1430 (byte) 0xae, 0x02, 0x01, 0x00, 0x04, 0x02, 0x02, 0x02,
1431 0x02, 0x02, 0x03, 0x00, 0x06, 0x19, 0x21, 0x68,
1432 0x07, 0x70, 0x01, 0x01, 0x09, 0x00, 0x05, 0x20,
1433 (byte) 0xc0, (byte) 0xa8, 0x4d, 0x01, 0x00, 0x03, 0x00, 0x30,
1434 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1435 0x00, 0x01, 0x00, 0x00, 0x1a, 0x02, 0x00, 0x00,
1436 0x04, 0x00, 0x00, 0x08, (byte) 0xae, 0x02, 0x01, 0x00,
1437 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x00,
1438 0x06, 0x19, 0x00, (byte) 0x95, 0x02, 0x50, 0x21, 0x01,
1439 0x09, 0x00, 0x05, 0x20, 0x15, 0x15, 0x15, 0x15,
1440 0x00, 0x03, 0x00, 0x30, 0x02, 0x00, 0x00, 0x00,
1441 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
1442 0x1a, 0x02, 0x00, 0x00, 0x04, 0x00, 0x00, 0x08,
1443 (byte) 0xae, 0x02, 0x01, 0x00, 0x04, 0x02, 0x02, 0x02,
1444 0x02, 0x02, 0x03, 0x00, 0x06, 0x02, 0x20, 0x22,
1445 0x02, 0x20, 0x22, 0x01, 0x09, 0x00, 0x05, 0x20,
1446 0x16, 0x16, 0x16, 0x16}; // prefix nlri
1447
1448 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
1449 buffer.writeBytes(updateMsg);
1450
1451 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
1452 BgpMessage message;
1453 BgpHeader bgpHeader = new BgpHeader();
1454
1455 message = reader.readFrom(buffer, bgpHeader);
1456
1457 assertThat(message, instanceOf(BgpUpdateMsg.class));
1458 }
1459
1460 /**
1461 * This test case checks update message with invalid link nlri length in input.
1462 */
1463 @Test(expected = BgpParseException.class)
1464 public void bgpUpdateMessageTest34() throws BgpParseException {
1465 byte[] updateMsg = new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1466 (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
1467 (byte) 0xff, (byte) 0xff, 0x00, (byte) 0x83, 0x02, 0x00, 0x04,
1468 0x18, 0x0a, 0x01, 0x01, //withdrawn routes
1469 0x00, 0x68, //path attribute len
1470 0x04, 0x01, 0x01, 0x00, //origin
1471 0x40, 0x02, 0x04, 0x02, 0x01, (byte) 0xfd, (byte) 0xe9, //as_path
1472 (byte) 0x80, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, //med
1473 (byte) 0x80, 0x0e, 0x53, 0x40, 0x04, 0x47, //mpreach
1474 0x04, 0x04, 0x00, 0x00, 0x01, //nexthop
1475 0x00, //reserved
1476 0x00, 0x02, 0x00, 0x48, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
1477 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x1b, 0x02, 0x00, 0x00,
1478 0x04, 0x00, 0x00, 0x08, (byte) 0xae, 0x02, 0x01, 0x00, 0x04,
1479 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x00, 0x07, 0x19, 0x00,
1480 (byte) 0x95, 0x02, 0x50, 0x21, 0x03, 0x01, 0x01, 0x00, 0x1a, 0x02,
1481 0x00, 0x00, 0x04, 0x00, 0x00, 0x08, (byte) 0xae, 0x02, 0x01, 0x00,
1482 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x00, 0x06, 0x19,
1483 0x00, (byte) 0x95, 0x02, 0x50, 0x21}; //link nlri
1484
1485 ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
1486 buffer.writeBytes(updateMsg);
1487
1488 BgpMessageReader<BgpMessage> reader = BgpFactories.getGenericReader();
1489 BgpMessage message;
1490 BgpHeader bgpHeader = new BgpHeader();
1491
1492 message = reader.readFrom(buffer, bgpHeader);
1493
1494 assertThat(message, instanceOf(BgpUpdateMsg.class));
1495 }
1496}