BUG 4181: Fix PCEP Parsers/Serializers
[bgpcep.git] / pcep / impl / src / test / java / org / opendaylight / protocol / pcep / impl / PCEPObjectParserTest.java
1 /*
2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
3  *
4  * This program and the accompanying materials are made available under the
5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6  * and is available at http://www.eclipse.org/legal/epl-v10.html
7  */
8 package org.opendaylight.protocol.pcep.impl;
9
10 import static org.junit.Assert.assertArrayEquals;
11 import static org.junit.Assert.assertEquals;
12 import static org.junit.Assert.assertNotNull;
13 import static org.junit.Assert.assertNull;
14 import static org.junit.Assert.assertTrue;
15 import static org.junit.Assert.fail;
16
17 import com.google.common.collect.Lists;
18 import com.google.common.primitives.UnsignedBytes;
19 import io.netty.buffer.ByteBuf;
20 import io.netty.buffer.Unpooled;
21 import java.io.IOException;
22 import java.util.List;
23 import org.junit.Before;
24 import org.junit.Test;
25 import org.opendaylight.protocol.pcep.impl.TestVendorInformationTlvParser.TestEnterpriseSpecificInformation;
26 import org.opendaylight.protocol.pcep.impl.object.PCEPBandwidthObjectParser;
27 import org.opendaylight.protocol.pcep.impl.object.PCEPClassTypeObjectParser;
28 import org.opendaylight.protocol.pcep.impl.object.PCEPCloseObjectParser;
29 import org.opendaylight.protocol.pcep.impl.object.PCEPEndPointsIpv4ObjectParser;
30 import org.opendaylight.protocol.pcep.impl.object.PCEPEndPointsIpv6ObjectParser;
31 import org.opendaylight.protocol.pcep.impl.object.PCEPErrorObjectParser;
32 import org.opendaylight.protocol.pcep.impl.object.PCEPExcludeRouteObjectParser;
33 import org.opendaylight.protocol.pcep.impl.object.PCEPExistingBandwidthObjectParser;
34 import org.opendaylight.protocol.pcep.impl.object.PCEPExplicitRouteObjectParser;
35 import org.opendaylight.protocol.pcep.impl.object.PCEPGlobalConstraintsObjectParser;
36 import org.opendaylight.protocol.pcep.impl.object.PCEPIncludeRouteObjectParser;
37 import org.opendaylight.protocol.pcep.impl.object.PCEPLoadBalancingObjectParser;
38 import org.opendaylight.protocol.pcep.impl.object.PCEPLspaObjectParser;
39 import org.opendaylight.protocol.pcep.impl.object.PCEPMetricObjectParser;
40 import org.opendaylight.protocol.pcep.impl.object.PCEPMonitoringObjectParser;
41 import org.opendaylight.protocol.pcep.impl.object.PCEPNoPathObjectParser;
42 import org.opendaylight.protocol.pcep.impl.object.PCEPNotificationObjectParser;
43 import org.opendaylight.protocol.pcep.impl.object.PCEPObjectiveFunctionObjectParser;
44 import org.opendaylight.protocol.pcep.impl.object.PCEPOpenObjectParser;
45 import org.opendaylight.protocol.pcep.impl.object.PCEPOverloadObjectParser;
46 import org.opendaylight.protocol.pcep.impl.object.PCEPPathKeyObjectParser;
47 import org.opendaylight.protocol.pcep.impl.object.PCEPPccIdReqIPv4ObjectParser;
48 import org.opendaylight.protocol.pcep.impl.object.PCEPPccIdReqIPv6ObjectParser;
49 import org.opendaylight.protocol.pcep.impl.object.PCEPPceIdIPv4ObjectParser;
50 import org.opendaylight.protocol.pcep.impl.object.PCEPPceIdIPv6ObjectParser;
51 import org.opendaylight.protocol.pcep.impl.object.PCEPProcTimeObjectParser;
52 import org.opendaylight.protocol.pcep.impl.object.PCEPReportedRouteObjectParser;
53 import org.opendaylight.protocol.pcep.impl.object.PCEPRequestParameterObjectParser;
54 import org.opendaylight.protocol.pcep.impl.object.PCEPSvecObjectParser;
55 import org.opendaylight.protocol.pcep.spi.ObjectHeaderImpl;
56 import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
57 import org.opendaylight.protocol.pcep.spi.PCEPErrors;
58 import org.opendaylight.protocol.pcep.spi.TlvRegistry;
59 import org.opendaylight.protocol.pcep.spi.UnknownObject;
60 import org.opendaylight.protocol.pcep.spi.VendorInformationTlvRegistry;
61 import org.opendaylight.protocol.pcep.spi.pojo.SimplePCEPExtensionProviderContext;
62 import org.opendaylight.protocol.util.ByteArray;
63 import org.opendaylight.protocol.util.Ipv4Util;
64 import org.opendaylight.protocol.util.Ipv6Util;
65 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.AsNumber;
66 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
67 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
68 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
69 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix;
70 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv6Address;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.iana.rev130816.EnterpriseNumber;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ieee754.rev130819.Float32;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.network.concepts.rev131125.Bandwidth;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.ClassType;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.OfId;
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.ProtocolVersion;
77 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.RequestId;
78 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.bandwidth.object.BandwidthBuilder;
79 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.classtype.object.ClassTypeBuilder;
80 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.close.object.CCloseBuilder;
81 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.endpoints.address.family.Ipv4CaseBuilder;
82 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.endpoints.address.family.Ipv6CaseBuilder;
83 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.endpoints.address.family.ipv4._case.Ipv4Builder;
84 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.endpoints.address.family.ipv6._case.Ipv6Builder;
85 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.endpoints.object.EndpointsObjBuilder;
86 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.exclude.route.object.XroBuilder;
87 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.exclude.route.object.xro.Subobject;
88 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.exclude.route.object.xro.SubobjectBuilder;
89 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.explicit.route.object.Ero;
90 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.explicit.route.object.EroBuilder;
91 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.gc.object.GcBuilder;
92 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.include.route.object.IroBuilder;
93 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.load.balancing.object.LoadBalancingBuilder;
94 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.lspa.object.LspaBuilder;
95 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.metric.object.MetricBuilder;
96 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.monitoring.object.Monitoring;
97 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.monitoring.object.Monitoring.Flags;
98 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.monitoring.object.MonitoringBuilder;
99 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.notification.object.CNotificationBuilder;
100 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.of.object.OfBuilder;
101 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.open.object.OpenBuilder;
102 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.order.tlv.OrderBuilder;
103 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.overload.duration.tlv.OverloadDurationBuilder;
104 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.overload.object.Overload;
105 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.overload.object.OverloadBuilder;
106 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.path.key.object.PathKeyBuilder;
107 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.path.key.object.path.key.PathKeys;
108 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.path.key.object.path.key.PathKeysBuilder;
109 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.path.setup.type.tlv.PathSetupTypeBuilder;
110 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcc.id.req.object.PccIdReq;
111 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcc.id.req.object.PccIdReqBuilder;
112 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pce.id.object.PceIdBuilder;
113 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcep.error.object.ErrorObjectBuilder;
114 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcep.error.object.error.object.TlvsBuilder;
115 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcrep.message.pcrep.message.replies.result.failure._case.NoPathBuilder;
116 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcrep.message.pcrep.message.replies.result.failure._case.no.path.tlvs.NoPathVectorBuilder;
117 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.proc.time.object.ProcTime;
118 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.proc.time.object.ProcTimeBuilder;
119 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.reported.route.object.RroBuilder;
120 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.req.missing.tlv.ReqMissingBuilder;
121 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.rp.object.RpBuilder;
122 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.svec.object.SvecBuilder;
123 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.vendor.information.objects.VendorInformationObject;
124 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.vendor.information.objects.VendorInformationObjectBuilder;
125 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.vendor.information.tlvs.VendorInformationTlv;
126 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.vendor.information.tlvs.VendorInformationTlvBuilder;
127 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.AttributeFilter;
128 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.ExcludeRouteSubobjects.Attribute;
129 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.PathKey;
130 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.PceId;
131 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.basic.explicit.route.subobjects.subobject.type.AsNumberCaseBuilder;
132 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.basic.explicit.route.subobjects.subobject.type.IpPrefixCaseBuilder;
133 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.basic.explicit.route.subobjects.subobject.type.UnnumberedCaseBuilder;
134 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.basic.explicit.route.subobjects.subobject.type.as.number._case.AsNumberBuilder;
135 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.basic.explicit.route.subobjects.subobject.type.ip.prefix._case.IpPrefixBuilder;
136 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.basic.explicit.route.subobjects.subobject.type.unnumbered._case.UnnumberedBuilder;
137
138 public class PCEPObjectParserTest {
139
140     private TlvRegistry tlvRegistry;
141
142     private VendorInformationTlvRegistry viTlvRegistry;
143
144     private SimplePCEPExtensionProviderContext ctx;
145     private Activator act;
146     private TestVendorInformationActivator viAct;
147
148     @Before
149     public void setUp() {
150         this.ctx = new SimplePCEPExtensionProviderContext();
151         this.act = new Activator();
152         this.viAct = new TestVendorInformationActivator();
153         this.act.start(this.ctx);
154         this.viAct.start(this.ctx);
155         this.tlvRegistry = this.ctx.getTlvHandlerRegistry();
156         this.viTlvRegistry = this.ctx.getVendorInformationTlvRegistry();
157     }
158
159     @Test
160     public void testOpenObjectWOTLV() throws PCEPDeserializerException, IOException {
161         final PCEPOpenObjectParser parser = new PCEPOpenObjectParser(this.tlvRegistry, this.viTlvRegistry);
162         final ByteBuf result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPOpenObject1.bin"));
163
164         final OpenBuilder builder = new OpenBuilder();
165         builder.setProcessingRule(false);
166         builder.setIgnore(false);
167         builder.setVersion(new ProtocolVersion((short) 1));
168         builder.setKeepalive((short) 30);
169         builder.setDeadTimer((short) 120);
170         builder.setSessionId((short) 1);
171
172         builder.setTlvs(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.open.object.open.TlvsBuilder().build());
173
174         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(false, false), result.slice(4, result.readableBytes() - 4)));
175         final ByteBuf buf = Unpooled.buffer();
176         parser.serializeObject(builder.build(), buf);
177         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
178
179         try {
180             parser.parseObject(new ObjectHeaderImpl(true, true), null);
181             fail();
182         } catch (final IllegalArgumentException e) {
183             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
184         }
185         try {
186             parser.parseObject(new ObjectHeaderImpl(true, true), Unpooled.EMPTY_BUFFER);
187             fail();
188         } catch (final IllegalArgumentException e) {
189             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
190         }
191     }
192
193     @Test
194     public void testCloseObject() throws IOException, PCEPDeserializerException {
195         final PCEPCloseObjectParser parser = new PCEPCloseObjectParser(this.tlvRegistry, this.viTlvRegistry);
196         final ByteBuf result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPCloseObject1.bin"));
197
198         final CCloseBuilder builder = new CCloseBuilder();
199         builder.setProcessingRule(false);
200         builder.setIgnore(false);
201         builder.setReason((short) 5);
202         builder.setTlvs(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.close.object.c.close.TlvsBuilder().build());
203
204         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(false, false), result.slice(4, result.readableBytes() - 4)));
205         final ByteBuf buf = Unpooled.buffer();
206         parser.serializeObject(builder.build(), buf);
207         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
208
209         try {
210             parser.parseObject(new ObjectHeaderImpl(true, true), null);
211             fail();
212         } catch (final IllegalArgumentException e) {
213             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
214         }
215         try {
216             parser.parseObject(new ObjectHeaderImpl(true, true), Unpooled.EMPTY_BUFFER);
217             fail();
218         } catch (final IllegalArgumentException e) {
219             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
220         }
221     }
222
223     @Test
224     public void testLoadBalancingObject() throws IOException, PCEPDeserializerException {
225         final PCEPLoadBalancingObjectParser parser = new PCEPLoadBalancingObjectParser();
226         final ByteBuf result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPLoadBalancingObject1.bin"));
227
228         final LoadBalancingBuilder builder = new LoadBalancingBuilder();
229         builder.setProcessingRule(true);
230         builder.setIgnore(false);
231         builder.setMaxLsp((short) UnsignedBytes.toInt((byte) 0xf1));
232         builder.setMinBandwidth(new Bandwidth(new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF }));
233
234         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, false), result.slice(4, result.readableBytes() - 4)));
235         final ByteBuf buf = Unpooled.buffer();
236         parser.serializeObject(builder.build(), buf);
237         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
238
239         try {
240             parser.parseObject(new ObjectHeaderImpl(true, true), null);
241             fail();
242         } catch (final IllegalArgumentException e) {
243             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
244         }
245         try {
246             parser.parseObject(new ObjectHeaderImpl(true, true), Unpooled.EMPTY_BUFFER);
247             fail();
248         } catch (final IllegalArgumentException e) {
249             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
250         }
251     }
252
253     @Test
254     public void testERObject() throws Exception {
255         final PCEPExplicitRouteObjectParser parser = new PCEPExplicitRouteObjectParser(this.ctx.getEROSubobjectHandlerRegistry());
256         final ByteBuf result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPExplicitRouteObject1PackOfSubobjects.bin"));
257
258         final EroBuilder builder = new EroBuilder();
259         builder.setProcessingRule(false);
260         builder.setIgnore(false);
261         final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.explicit.route.object.ero.Subobject> subs = Lists.newArrayList();
262         subs.add(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.explicit.route.object.ero.SubobjectBuilder().setLoose(
263                 true).setSubobjectType(
264                         new AsNumberCaseBuilder().setAsNumber(new AsNumberBuilder().setAsNumber(new AsNumber(0xffffL)).build()).build()).build());
265         subs.add(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.explicit.route.object.ero.SubobjectBuilder().setLoose(
266                 true).setSubobjectType(
267                         new IpPrefixCaseBuilder().setIpPrefix(
268                                 new IpPrefixBuilder().setIpPrefix(new IpPrefix(new Ipv4Prefix("255.255.255.255/32"))).build()).build()).build());
269         subs.add(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.explicit.route.object.ero.SubobjectBuilder().setLoose(
270                 true).setSubobjectType(
271                         new UnnumberedCaseBuilder().setUnnumbered(
272                                 new UnnumberedBuilder().setRouterId(0xffffffffL).setInterfaceId(0xffffffffL).build()).build()).build());
273         builder.setSubobject(subs);
274
275         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(false, false), result.slice(4, result.readableBytes() - 4)));
276         final ByteBuf buf = Unpooled.buffer();
277         parser.serializeObject(builder.build(), buf);
278         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
279
280         try {
281             parser.parseObject(new ObjectHeaderImpl(true, true), null);
282             fail();
283         } catch (final IllegalArgumentException e) {
284             assertEquals("Array of bytes is mandatory. Can't be null.", e.getMessage());
285         }
286     }
287
288     @Test
289     public void testIRObject() throws Exception {
290         final PCEPIncludeRouteObjectParser parser = new PCEPIncludeRouteObjectParser(this.ctx.getEROSubobjectHandlerRegistry());
291         final ByteBuf result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPIncludeRouteObject1PackOfSubobjects.bin"));
292         final byte[] ip6PrefixBytes = { (byte) 0x12, (byte) 0x34, (byte) 0x54, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
293             (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00 };
294
295         final IroBuilder builder = new IroBuilder();
296         builder.setProcessingRule(false);
297         builder.setIgnore(false);
298         final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.include.route.object.iro.Subobject> subs = Lists.newArrayList();
299         subs.add(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.include.route.object.iro.SubobjectBuilder().setSubobjectType(
300                 new AsNumberCaseBuilder().setAsNumber(new AsNumberBuilder().setAsNumber(new AsNumber(0x10L)).build()).build()).build());
301         subs.add(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.include.route.object.iro.SubobjectBuilder().setSubobjectType(
302                 new IpPrefixCaseBuilder().setIpPrefix(
303                         new IpPrefixBuilder().setIpPrefix(new IpPrefix(new Ipv4Prefix("18.52.80.0/21"))).build()).build()).build());
304         subs.add(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.include.route.object.iro.SubobjectBuilder().setSubobjectType(
305                 new IpPrefixCaseBuilder().setIpPrefix(
306                         new IpPrefixBuilder().setIpPrefix(new IpPrefix(Ipv6Util.prefixForBytes(ip6PrefixBytes, 22))).build()).build()).build());
307         subs.add(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.include.route.object.iro.SubobjectBuilder().setSubobjectType(
308                 new UnnumberedCaseBuilder().setUnnumbered(
309                         new UnnumberedBuilder().setRouterId(0x1245678L).setInterfaceId(0x9abcdef0L).build()).build()).build());
310         builder.setSubobject(subs);
311
312         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(false, false), result.slice(4, result.readableBytes() - 4)));
313         final ByteBuf buf = Unpooled.buffer();
314         parser.serializeObject(builder.build(), buf);
315         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
316
317         try {
318             parser.parseObject(new ObjectHeaderImpl(true, true), null);
319             fail();
320         } catch (final IllegalArgumentException e) {
321             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
322         }
323         try {
324             parser.parseObject(new ObjectHeaderImpl(true, true), Unpooled.EMPTY_BUFFER);
325             fail();
326         } catch (final IllegalArgumentException e) {
327             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
328         }
329     }
330
331     @Test
332     public void testRRObject() throws Exception {
333         final PCEPReportedRouteObjectParser parser = new PCEPReportedRouteObjectParser(this.ctx.getRROSubobjectHandlerRegistry());
334         final ByteBuf result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPReportedRouteObject1PackOfSubobjects.bin"));
335         final byte[] ip6PrefixBytes = { (byte) 0x12, (byte) 0x34, (byte) 0x54, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
336             (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00 };
337
338         final RroBuilder builder = new RroBuilder();
339         builder.setProcessingRule(false);
340         builder.setIgnore(false);
341         final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.reported.route.object.rro.Subobject> subs = Lists.newArrayList();
342         subs.add(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.reported.route.object.rro.SubobjectBuilder().setSubobjectType(
343                 new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.record.route.subobjects.subobject.type.IpPrefixCaseBuilder().setIpPrefix(
344                         new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.record.route.subobjects.subobject.type.ip.prefix._case.IpPrefixBuilder().setIpPrefix(
345                                 new IpPrefix(new Ipv4Prefix("255.255.255.255/32"))).build()).build()).setProtectionAvailable(false).setProtectionInUse(
346                                         false).build());
347         subs.add(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.reported.route.object.rro.SubobjectBuilder().setSubobjectType(
348                 new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.record.route.subobjects.subobject.type.IpPrefixCaseBuilder().setIpPrefix(
349                         new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.record.route.subobjects.subobject.type.ip.prefix._case.IpPrefixBuilder().setIpPrefix(
350                                 new IpPrefix(Ipv6Util.prefixForBytes(ip6PrefixBytes, 22))).build()).build()).setProtectionAvailable(false).setProtectionInUse(
351                                         false).build());
352         subs.add(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.reported.route.object.rro.SubobjectBuilder().setSubobjectType(
353                 new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.record.route.subobjects.subobject.type.UnnumberedCaseBuilder().setUnnumbered(
354                         new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.record.route.subobjects.subobject.type.unnumbered._case.UnnumberedBuilder().setRouterId(
355                                 0x1245678L).setInterfaceId(0x9abcdef0L).build()).build()).setProtectionAvailable(false).setProtectionInUse(
356                                         false).build());
357         builder.setSubobject(subs);
358
359         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(false, false), result.slice(4, result.readableBytes() - 4)));
360         final ByteBuf buf = Unpooled.buffer();
361         parser.serializeObject(builder.build(), buf);
362         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
363
364         try {
365             parser.parseObject(new ObjectHeaderImpl(true, true), null);
366             fail();
367         } catch (final IllegalArgumentException e) {
368             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
369         }
370         try {
371             parser.parseObject(new ObjectHeaderImpl(true, true), Unpooled.EMPTY_BUFFER);
372             fail();
373         } catch (final IllegalArgumentException e) {
374             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
375         }
376     }
377
378     @Test
379     public void testBandwidthObject() throws IOException, PCEPDeserializerException {
380         final PCEPBandwidthObjectParser parser = new PCEPBandwidthObjectParser();
381         final ByteBuf result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPBandwidthObject1LowerBounds.bin"));
382
383         final BandwidthBuilder builder = new BandwidthBuilder();
384         builder.setProcessingRule(true);
385         builder.setIgnore(true);
386         builder.setBandwidth(new Bandwidth(new byte[] { (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00 }));
387
388         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result.slice(4, result.readableBytes() - 4)));
389         final ByteBuf buf = Unpooled.buffer();
390         parser.serializeObject(builder.build(), buf);
391         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
392
393         try {
394             parser.parseObject(new ObjectHeaderImpl(true, true), null);
395             fail();
396         } catch (final IllegalArgumentException e) {
397             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
398         }
399         try {
400             parser.parseObject(new ObjectHeaderImpl(true, true), Unpooled.EMPTY_BUFFER);
401             fail();
402         } catch (final IllegalArgumentException e) {
403             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
404         }
405     }
406
407     @Test
408     public void testExistingBandwidthObject() throws IOException, PCEPDeserializerException {
409         final PCEPExistingBandwidthObjectParser parser = new PCEPExistingBandwidthObjectParser();
410         final ByteBuf result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPBandwidthObject2UpperBounds.bin"));
411
412         final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.reoptimization
413             .bandwidth.object.BandwidthBuilder builder = new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml
414             .ns.yang.pcep.types.rev131005.reoptimization.bandwidth.object.BandwidthBuilder();
415         builder.setProcessingRule(true);
416         builder.setIgnore(true);
417         builder.setBandwidth(new Bandwidth(new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF }));
418
419         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result.slice(4, result.readableBytes() - 4)));
420         final ByteBuf buf = Unpooled.buffer();
421         parser.serializeObject(builder.build(), buf);
422         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
423
424         try {
425             parser.parseObject(new ObjectHeaderImpl(true, true), null);
426             fail();
427         } catch (final IllegalArgumentException e) {
428             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
429         }
430         try {
431             parser.parseObject(new ObjectHeaderImpl(true, true), Unpooled.EMPTY_BUFFER);
432             fail();
433         } catch (final IllegalArgumentException e) {
434             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
435         }
436     }
437
438     @Test
439     public void testEndPointsObjectIPv4() throws IOException, PCEPDeserializerException {
440         final byte[] srcIPBytes = { (byte) 0xA2, (byte) 0xF5, (byte) 0x11, (byte) 0x0E };
441         final byte[] destIPBytes = { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF };
442
443         final PCEPEndPointsIpv4ObjectParser parser = new PCEPEndPointsIpv4ObjectParser();
444         final ByteBuf result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPEndPointsObject1IPv4.bin"));
445
446         final EndpointsObjBuilder builder = new EndpointsObjBuilder();
447         builder.setProcessingRule(true);
448         builder.setIgnore(false);
449         builder.setAddressFamily(new Ipv4CaseBuilder().setIpv4(
450                 new Ipv4Builder().setSourceIpv4Address(Ipv4Util.addressForByteBuf(Unpooled.wrappedBuffer(srcIPBytes))).setDestinationIpv4Address(
451                         Ipv4Util.addressForByteBuf(Unpooled.wrappedBuffer(destIPBytes))).build()).build());
452
453         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, false), result.slice(4, result.readableBytes() - 4)));
454         final ByteBuf buf = Unpooled.buffer();
455         parser.serializeObject(builder.build(), buf);
456         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
457
458         try {
459             parser.parseObject(new ObjectHeaderImpl(true, true), null);
460             fail();
461         } catch (final IllegalArgumentException e) {
462             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
463         }
464         try {
465             parser.parseObject(new ObjectHeaderImpl(true, true), Unpooled.EMPTY_BUFFER);
466             fail();
467         } catch (final IllegalArgumentException e) {
468             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
469         }
470     }
471
472     @Test
473     public void testEndPointsObjectIPv6() throws IOException, PCEPDeserializerException {
474         final byte[] destIPBytes = { (byte) 0x00, (byte) 0x02, (byte) 0x5D, (byte) 0xD2, (byte) 0xFF, (byte) 0xEC, (byte) 0xA1,
475             (byte) 0xB6, (byte) 0x58, (byte) 0x1E, (byte) 0x9F, (byte) 0x50, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, };
476         final byte[] srcIPBytes = { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
477             (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF };
478
479         final PCEPEndPointsIpv6ObjectParser parser = new PCEPEndPointsIpv6ObjectParser();
480         final ByteBuf result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPEndPointsObject2IPv6.bin"));
481
482         final EndpointsObjBuilder builder = new EndpointsObjBuilder();
483         builder.setProcessingRule(true);
484         builder.setIgnore(false);
485         builder.setAddressFamily(new Ipv6CaseBuilder().setIpv6(
486                 new Ipv6Builder().setSourceIpv6Address(Ipv6Util.addressForByteBuf(Unpooled.wrappedBuffer(srcIPBytes))).setDestinationIpv6Address(
487                         Ipv6Util.addressForByteBuf(Unpooled.wrappedBuffer(destIPBytes))).build()).build());
488
489         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, false), result.slice(4, result.readableBytes() - 4)));
490         final ByteBuf buf = Unpooled.buffer();
491         parser.serializeObject(builder.build(), buf);
492         assertArrayEquals(result.array(),ByteArray.getAllBytes(buf));
493
494         try {
495             parser.parseObject(new ObjectHeaderImpl(true, true), null);
496             fail();
497         } catch (final IllegalArgumentException e) {
498             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
499         }
500         try {
501             parser.parseObject(new ObjectHeaderImpl(true, true), Unpooled.EMPTY_BUFFER);
502             fail();
503         } catch (final IllegalArgumentException e) {
504             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
505         }
506     }
507
508     @Test
509     public void testErrorObjectWithTlv() throws PCEPDeserializerException, IOException {
510         final PCEPErrorObjectParser parser = new PCEPErrorObjectParser(this.tlvRegistry, this.viTlvRegistry);
511         ByteBuf result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPErrorObject1.bin"));
512
513         final ErrorObjectBuilder builder = new ErrorObjectBuilder();
514         builder.setProcessingRule(true);
515         builder.setIgnore(true);
516         builder.setType((short) 1);
517         builder.setValue((short) 1);
518
519         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result.slice(4, result.readableBytes() - 4)));
520         ByteBuf buf = Unpooled.buffer();
521         parser.serializeObject(builder.build(), buf);
522         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
523
524         result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPErrorObject3.bin"));
525
526         builder.setType((short) 7);
527         builder.setValue((short) 0);
528         builder.setTlvs(new TlvsBuilder().setReqMissing(new ReqMissingBuilder().setRequestId(new RequestId(0x00001155L)).build()).build());
529
530         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result.slice(4, result.readableBytes() - 4)));
531         buf = Unpooled.buffer();
532         parser.serializeObject(builder.build(), buf);
533         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
534
535         try {
536             parser.parseObject(new ObjectHeaderImpl(true, true), null);
537             fail();
538         } catch (final IllegalArgumentException e) {
539             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
540         }
541         try {
542             parser.parseObject(new ObjectHeaderImpl(true, true), Unpooled.EMPTY_BUFFER);
543             fail();
544         } catch (final IllegalArgumentException e) {
545             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
546         }
547     }
548
549     @Test
550     public void testLspaObject() throws IOException, PCEPDeserializerException {
551         final PCEPLspaObjectParser parser = new PCEPLspaObjectParser(this.tlvRegistry, this.viTlvRegistry);
552         ByteBuf result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPLspaObject1LowerBounds.bin"));
553
554         final LspaBuilder builder = new LspaBuilder();
555         builder.setProcessingRule(true);
556         builder.setIgnore(true);
557         builder.setExcludeAny(new AttributeFilter(0L));
558         builder.setIncludeAny(new AttributeFilter(0L));
559         builder.setIncludeAll(new AttributeFilter(0L));
560         builder.setHoldPriority((short) 0);
561         builder.setSetupPriority((short) 0);
562         builder.setLocalProtectionDesired(false);
563         builder.setTlvs(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.lspa.object.lspa.TlvsBuilder().build());
564
565         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result.slice(4, result.readableBytes() - 4)));
566         ByteBuf buf = Unpooled.buffer();
567         parser.serializeObject(builder.build(), buf);
568         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
569
570         result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPLspaObject2UpperBounds.bin"));
571
572         builder.setExcludeAny(new AttributeFilter(0xFFFFFFFFL));
573         builder.setIncludeAny(new AttributeFilter(0xFFFFFFFFL));
574         builder.setIncludeAll(new AttributeFilter(0xFFFFFFFFL));
575         builder.setHoldPriority((short) 0xFF);
576         builder.setSetupPriority((short) 0xFF);
577         builder.setLocalProtectionDesired(true);
578
579         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result.slice(4, result.readableBytes() - 4)));
580         buf = Unpooled.buffer();
581         parser.serializeObject(builder.build(), buf);
582         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
583
584         try {
585             parser.parseObject(new ObjectHeaderImpl(true, true), null);
586             fail();
587         } catch (final IllegalArgumentException e) {
588             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
589         }
590         try {
591             parser.parseObject(new ObjectHeaderImpl(true, true), Unpooled.EMPTY_BUFFER);
592             fail();
593         } catch (final IllegalArgumentException e) {
594             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
595         }
596     }
597
598     @Test
599     public void testMetricObject() throws IOException, PCEPDeserializerException {
600         final PCEPMetricObjectParser parser = new PCEPMetricObjectParser();
601         ByteBuf result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPMetricObject1LowerBounds.bin"));
602
603         final MetricBuilder builder = new MetricBuilder();
604         builder.setProcessingRule(true);
605         builder.setIgnore(true);
606         builder.setComputed(false);
607         builder.setBound(false);
608         builder.setMetricType((short) 1);
609         builder.setValue(new Float32(new byte[] { 0, 0, 0, 0 }));
610
611         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result.slice(4, result.readableBytes() - 4)));
612         ByteBuf buf = Unpooled.buffer();
613         parser.serializeObject(builder.build(), buf);
614         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
615
616         result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPMetricObject2UpperBounds.bin"));
617
618         builder.setComputed(true);
619         builder.setBound(false);
620         builder.setMetricType((short) 2);
621         builder.setValue(new Float32(new byte[] { (byte) 0x4f, (byte) 0x70, (byte) 0x00, (byte) 0x00 }));
622
623         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result.slice(4, result.readableBytes() - 4)));
624         buf = Unpooled.buffer();
625         parser.serializeObject(builder.build(), buf);
626         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
627
628         try {
629             parser.parseObject(new ObjectHeaderImpl(true, true), null);
630             fail();
631         } catch (final IllegalArgumentException e) {
632             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
633         }
634         try {
635             parser.parseObject(new ObjectHeaderImpl(true, true), Unpooled.EMPTY_BUFFER);
636             fail();
637         } catch (final IllegalArgumentException e) {
638             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
639         }
640     }
641
642     @Test
643     public void testNoPathObjectWithTlv() throws PCEPDeserializerException, IOException {
644         final PCEPNoPathObjectParser parser = new PCEPNoPathObjectParser(this.tlvRegistry, this.viTlvRegistry);
645         ByteBuf result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPNoPathObject1WithoutTLV.bin"));
646
647         final NoPathBuilder builder = new NoPathBuilder();
648         builder.setProcessingRule(true);
649         builder.setIgnore(true);
650         builder.setNatureOfIssue((short) 1);
651         builder.setUnsatisfiedConstraints(true);
652         builder.setTlvs(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcrep.message.pcrep.message.replies.result.failure._case.no.path.TlvsBuilder().build());
653
654         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result.slice(4, result.readableBytes() - 4)));
655         ByteBuf buf = Unpooled.buffer();
656         parser.serializeObject(builder.build(), buf);
657         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
658
659         result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPNoPathObject2WithTLV.bin"));
660
661         builder.setNatureOfIssue((short) 0);
662         builder.setUnsatisfiedConstraints(false);
663
664         final NoPathVectorBuilder b = new NoPathVectorBuilder();
665         b.setFlags(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.NoPathVectorTlv.Flags(false, true, false, true, false, true, true, true));
666         builder.setTlvs(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcrep.message.pcrep.message.replies.result.failure._case.no.path.TlvsBuilder().setNoPathVector(
667                 b.build()).build());
668
669         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result.slice(4, result.readableBytes() - 4)));
670         buf = Unpooled.buffer();
671         parser.serializeObject(builder.build(), buf);
672         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
673
674         try {
675             parser.parseObject(new ObjectHeaderImpl(true, true), null);
676             fail();
677         } catch (final IllegalArgumentException e) {
678             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
679         }
680         try {
681             parser.parseObject(new ObjectHeaderImpl(true, true), Unpooled.EMPTY_BUFFER);
682             fail();
683         } catch (final IllegalArgumentException e) {
684             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
685         }
686     }
687
688     @Test
689     public void testNotifyObjectWithTlv() throws PCEPDeserializerException, IOException {
690         final PCEPNotificationObjectParser parser = new PCEPNotificationObjectParser(this.tlvRegistry, this.viTlvRegistry);
691         ByteBuf result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPNotificationObject2WithoutTlv.bin"));
692
693         final CNotificationBuilder builder = new CNotificationBuilder();
694         builder.setProcessingRule(true);
695         builder.setIgnore(true);
696         builder.setType((short) 0xff);
697         builder.setValue((short) 0xff);
698
699         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result.slice(4, result.readableBytes() - 4)));
700         ByteBuf buf = Unpooled.buffer();
701         parser.serializeObject(builder.build(), buf);
702         assertArrayEquals(result.array(),ByteArray.getAllBytes(buf));
703
704         result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPNotificationObject1WithTlv.bin"));
705
706         builder.setType((short) 2);
707         builder.setValue((short) 1);
708         builder.setTlvs(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.notification.object.c.notification.TlvsBuilder().setOverloadDuration(
709                 new OverloadDurationBuilder().setDuration(0xff0000a2L).build()).build());
710
711         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result.slice(4, result.readableBytes() - 4)));
712         buf = Unpooled.buffer();
713         parser.serializeObject(builder.build(), buf);
714         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
715
716         try {
717             parser.parseObject(new ObjectHeaderImpl(true, true), null);
718             fail();
719         } catch (final IllegalArgumentException e) {
720             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
721         }
722         try {
723             parser.parseObject(new ObjectHeaderImpl(true, true), Unpooled.EMPTY_BUFFER);
724             fail();
725         } catch (final IllegalArgumentException e) {
726             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
727         }
728     }
729
730     @Test
731     public void testRPObjectWithTlv() throws PCEPDeserializerException, IOException {
732         final PCEPRequestParameterObjectParser parser = new PCEPRequestParameterObjectParser(this.tlvRegistry, this.viTlvRegistry);
733         ByteBuf result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPRPObject1.bin"));
734
735         final RpBuilder builder = new RpBuilder();
736         builder.setProcessingRule(true);
737         builder.setIgnore(true);
738         builder.setReoptimization(true);
739         builder.setBiDirectional(false);
740         builder.setLoose(true);
741         builder.setMakeBeforeBreak(true);
742         builder.setOrder(false);
743         builder.setPathKey(false);
744         builder.setSupplyOf(false);
745         builder.setFragmentation(false);
746         builder.setP2mp(false);
747         builder.setEroCompression(false);
748         builder.setPriority((short) 5);
749         builder.setRequestId(new RequestId(0xdeadbeefL));
750         builder.setTlvs(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.rp.object.rp.TlvsBuilder().build());
751
752         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result.slice(4, result.readableBytes() - 4)));
753         ByteBuf buf = Unpooled.buffer();
754         parser.serializeObject(builder.build(), buf);
755         assertArrayEquals(result.array(),ByteArray.getAllBytes(buf));
756
757         result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPRPObject2.bin"));
758
759         builder.setReoptimization(false);
760         builder.setFragmentation(true);
761         builder.setEroCompression(true);
762
763         final OrderBuilder b = new OrderBuilder();
764         b.setDelete(0xffffffffL);
765         b.setSetup(1L);
766
767         builder.setTlvs(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.rp.object.rp.TlvsBuilder().setOrder(
768                 b.build()).build());
769
770         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result.slice(4, result.readableBytes() - 4)));
771         buf = Unpooled.buffer();
772         parser.serializeObject(builder.build(), buf);
773         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
774
775         try {
776             parser.parseObject(new ObjectHeaderImpl(true, true), null);
777             fail();
778         } catch (final IllegalArgumentException e) {
779             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
780         }
781         try {
782             parser.parseObject(new ObjectHeaderImpl(true, true), Unpooled.EMPTY_BUFFER);
783             fail();
784         } catch (final IllegalArgumentException e) {
785             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
786         }
787     }
788
789     @Test
790     public void testSvecObject() throws IOException, PCEPDeserializerException {
791         final PCEPSvecObjectParser parser = new PCEPSvecObjectParser();
792         ByteBuf result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPSvecObject2.bin"));
793
794         final SvecBuilder builder = new SvecBuilder();
795         builder.setProcessingRule(false);
796         builder.setIgnore(false);
797         builder.setLinkDiverse(false);
798         builder.setNodeDiverse(false);
799         builder.setSrlgDiverse(false);
800         builder.setRequestsIds(Lists.newArrayList(new RequestId(0xFFL)));
801
802         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(false, false), result.slice(4, result.readableBytes() - 4)));
803         ByteBuf buf = Unpooled.buffer();
804         parser.serializeObject(builder.build(), buf);
805         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
806
807         result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPSvecObject1_10ReqIDs.bin"));
808
809         builder.setProcessingRule(true);
810         builder.setLinkDiverse(true);
811         builder.setSrlgDiverse(true);
812
813         final List<RequestId> requestIDs = Lists.newArrayList();
814         requestIDs.add(new RequestId(0xFFFFFFFFL));
815         requestIDs.add(new RequestId(0x00000001L));
816         requestIDs.add(new RequestId(0x01234567L));
817         requestIDs.add(new RequestId(0x89ABCDEFL));
818         requestIDs.add(new RequestId(0xFEDCBA98L));
819         requestIDs.add(new RequestId(0x76543210L));
820         requestIDs.add(new RequestId(0x15825266L));
821         requestIDs.add(new RequestId(0x48120BBEL));
822         requestIDs.add(new RequestId(0x25FB7E52L));
823         requestIDs.add(new RequestId(0xB2F2546BL));
824
825         builder.setRequestsIds(requestIDs);
826
827         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, false), result.slice(4, result.readableBytes() - 4)));
828         buf = Unpooled.buffer();
829         parser.serializeObject(builder.build(), buf);
830         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
831
832         try {
833             parser.parseObject(new ObjectHeaderImpl(true, true), null);
834             fail();
835         } catch (final IllegalArgumentException e) {
836             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
837         }
838         try {
839             parser.parseObject(new ObjectHeaderImpl(true, true), Unpooled.EMPTY_BUFFER);
840             fail();
841         } catch (final IllegalArgumentException e) {
842             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
843         }
844     }
845
846     @Test
847     public void testClassTypeObject() throws PCEPDeserializerException {
848         final PCEPClassTypeObjectParser parser = new PCEPClassTypeObjectParser();
849         final ByteBuf result = Unpooled.wrappedBuffer(new byte[] { (byte) 0x16, (byte) 0x12, (byte) 0x00, (byte) 0x08, 0, 0, 0, (byte) 0x04 });
850
851         final ClassTypeBuilder builder = new ClassTypeBuilder();
852         builder.setProcessingRule(true);
853         builder.setIgnore(false);
854         builder.setClassType(new ClassType((short) 4));
855
856         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, false), result.slice(4, result.readableBytes() - 4)));
857         final ByteBuf buf = Unpooled.buffer();
858         parser.serializeObject(builder.build(), buf);
859         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
860
861         try {
862             parser.parseObject(new ObjectHeaderImpl(true, true), null);
863             fail();
864         } catch (final IllegalArgumentException e) {
865             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
866         }
867         try {
868             parser.parseObject(new ObjectHeaderImpl(true, true), Unpooled.EMPTY_BUFFER);
869             fail();
870         } catch (final IllegalArgumentException e) {
871             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
872         }
873     }
874
875     @Test
876     public void testExcludeRouteObject() throws Exception {
877         final PCEPExcludeRouteObjectParser parser = new PCEPExcludeRouteObjectParser(this.ctx.getXROSubobjectHandlerRegistry());
878         final ByteBuf result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPExcludeRouteObject.1.bin"));
879
880         final XroBuilder builder = new XroBuilder();
881         builder.setProcessingRule(false);
882         builder.setIgnore(false);
883         builder.setFlags(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.exclude.route.object.Xro.Flags(true));
884         final List<Subobject> subs = Lists.newArrayList();
885         subs.add(new SubobjectBuilder().setMandatory(true).setSubobjectType(
886                 new IpPrefixCaseBuilder().setIpPrefix(
887                         new IpPrefixBuilder().setIpPrefix(new IpPrefix(new Ipv4Prefix("192.168.0.0/16"))).build()).build()).setAttribute(
888                                 Attribute.Node).build());
889         subs.add(new SubobjectBuilder().setMandatory(false).setSubobjectType(
890                 new AsNumberCaseBuilder().setAsNumber(new AsNumberBuilder().setAsNumber(new AsNumber(0x1234L)).build()).build()).build());
891         builder.setSubobject(subs);
892
893         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(false, false), result.slice(4, result.readableBytes() - 4)));
894         final ByteBuf buf = Unpooled.buffer();
895         parser.serializeObject(builder.build(), buf);
896         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
897
898         try {
899             parser.parseObject(new ObjectHeaderImpl(true, true), null);
900             fail();
901         } catch (final IllegalArgumentException e) {
902             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
903         }
904         try {
905             parser.parseObject(new ObjectHeaderImpl(true, true), Unpooled.EMPTY_BUFFER);
906             fail();
907         } catch (final IllegalArgumentException e) {
908             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
909         }
910     }
911
912     @Test
913     public void testPathKeyObject() throws Exception {
914         final PCEPPathKeyObjectParser parser = new PCEPPathKeyObjectParser(this.ctx.getEROSubobjectHandlerRegistry());
915         final ByteBuf result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPPathKeyObject.bin"));
916
917         final PathKeyBuilder builder = new PathKeyBuilder();
918         builder.setProcessingRule(true);
919         builder.setIgnore(false);
920         final List<PathKeys> list = Lists.newArrayList();
921         list.add(new PathKeysBuilder().setLoose(true).setPathKey(new PathKey(0x1234)).setPceId(
922                 new PceId(new byte[] { (byte) 0x12, (byte) 0x34, (byte) 0x50, (byte) 0x00 })).build());
923         builder.setPathKeys(list);
924
925         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, false), result.slice(4, result.readableBytes() - 4)));
926         final ByteBuf buf = Unpooled.buffer();
927         parser.serializeObject(builder.build(), buf);
928         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
929
930         try {
931             parser.parseObject(new ObjectHeaderImpl(true, true), null);
932             fail();
933         } catch (final IllegalArgumentException e) {
934             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
935         }
936         try {
937             parser.parseObject(new ObjectHeaderImpl(true, true), Unpooled.EMPTY_BUFFER);
938             fail();
939         } catch (final IllegalArgumentException e) {
940             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
941         }
942     }
943
944     @Test
945     public void testObjectiveFunctionObject() throws IOException, PCEPDeserializerException {
946         final PCEPObjectiveFunctionObjectParser parser = new PCEPObjectiveFunctionObjectParser(this.tlvRegistry, this.viTlvRegistry);
947         final ByteBuf result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPObjectiveFunctionObject.1.bin"));
948
949         final OfBuilder builder = new OfBuilder();
950         builder.setProcessingRule(true);
951         builder.setIgnore(false);
952         builder.setCode(new OfId(4));
953         builder.setTlvs(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.of.object.of.TlvsBuilder().build());
954
955         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, false), result.slice(4, result.readableBytes() - 4)));
956         final ByteBuf buf = Unpooled.buffer();
957         parser.serializeObject(builder.build(), buf);
958         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
959
960         try {
961             parser.parseObject(new ObjectHeaderImpl(true, true), null);
962             fail();
963         } catch (final IllegalArgumentException e) {
964             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
965         }
966         try {
967             parser.parseObject(new ObjectHeaderImpl(true, true), Unpooled.EMPTY_BUFFER);
968             fail();
969         } catch (final IllegalArgumentException e) {
970             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
971         }
972     }
973
974     @Test
975     public void testGlobalConstraintsObject() throws IOException, PCEPDeserializerException {
976         final PCEPGlobalConstraintsObjectParser parser = new PCEPGlobalConstraintsObjectParser(this.tlvRegistry, this.viTlvRegistry);
977         final ByteBuf result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPGlobalConstraintsObject.1.bin"));
978
979         final GcBuilder builder = new GcBuilder();
980         builder.setProcessingRule(true);
981         builder.setIgnore(false);
982         builder.setMaxHop((short) 1);
983         builder.setMaxUtilization((short) 0);
984         builder.setMinUtilization((short) 100);
985         builder.setOverBookingFactor((short) 99);
986         builder.setTlvs(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.gc.object.gc.TlvsBuilder().build());
987
988         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, false), result.slice(4, result.readableBytes() - 4)));
989         final ByteBuf buf = Unpooled.buffer();
990         parser.serializeObject(builder.build(), buf);
991         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
992
993         try {
994             parser.parseObject(new ObjectHeaderImpl(true, true), null);
995             fail();
996         } catch (final IllegalArgumentException e) {
997             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
998         }
999         try {
1000             parser.parseObject(new ObjectHeaderImpl(true, true), Unpooled.EMPTY_BUFFER);
1001             fail();
1002         } catch (final IllegalArgumentException e) {
1003             assertEquals("Array of bytes is mandatory. Can't be null or empty.", e.getMessage());
1004         }
1005     }
1006
1007     @Test
1008     public void testIgnoreUknownObject() throws PCEPDeserializerException {
1009         final Object object = this.ctx.getObjectHandlerRegistry().parseObject(35, 1, new ObjectHeaderImpl(false, false), null);
1010         assertNull(object);
1011     }
1012
1013     @Test
1014     public void testUnrecognizedObjectType() throws PCEPDeserializerException {
1015         final Object object = this.ctx.getObjectHandlerRegistry().parseObject(2, 2, new ObjectHeaderImpl(true, true), null);
1016         assertNotNull(object);
1017         assertTrue(object instanceof UnknownObject);
1018         assertEquals(PCEPErrors.UNRECOGNIZED_OBJ_TYPE, ((UnknownObject) object).getError());
1019     }
1020
1021     @Test
1022     public void testUnrecognizedObjectClass() throws PCEPDeserializerException {
1023         final Object object = this.ctx.getObjectHandlerRegistry().parseObject(35, 1, new ObjectHeaderImpl(true, true), null);
1024         assertNotNull(object);
1025         assertTrue(object instanceof UnknownObject);
1026         assertEquals(PCEPErrors.UNRECOGNIZED_OBJ_CLASS, ((UnknownObject) object).getError());
1027     }
1028
1029     @Test
1030     public void testLspaObjectSerializerDefence() throws IOException, PCEPDeserializerException {
1031         final PCEPLspaObjectParser parser = new PCEPLspaObjectParser(this.tlvRegistry, this.viTlvRegistry);
1032         final ByteBuf result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCEPLspaObject1LowerBounds.bin"));
1033
1034         final LspaBuilder builder = new LspaBuilder();
1035         builder.setProcessingRule(true);
1036         builder.setIgnore(true);
1037         builder.setLocalProtectionDesired(false);
1038
1039         final ByteBuf buf = Unpooled.buffer(result.readableBytes());
1040         parser.serializeObject(builder.build(), buf);
1041         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
1042     }
1043
1044     @Test
1045     public void testEmptyEroObject() throws PCEPDeserializerException {
1046         final Object object = this.ctx.getObjectHandlerRegistry().parseObject(PCEPExplicitRouteObjectParser.CLASS, PCEPExplicitRouteObjectParser.TYPE, new ObjectHeaderImpl(true, true), Unpooled.EMPTY_BUFFER);
1047         assertNotNull(object);
1048         assertTrue(object instanceof Ero);
1049         final Ero eroObject = (Ero) object;
1050         assertTrue(eroObject.getSubobject().isEmpty());
1051
1052         final ByteBuf buffer = Unpooled.buffer();
1053         this.ctx.getObjectHandlerRegistry().serializeObject(eroObject, buffer);
1054         final byte[] expected = {0x07, 0x13, 0x00, 0x04};
1055         assertArrayEquals(expected, ByteArray.getAllBytes(buffer));
1056     }
1057
1058     @Test
1059     public void testCloseObjectWithVendorInformationTlv() throws IOException, PCEPDeserializerException {
1060         final byte[] closeBytes = {
1061             0x0f, 0x10, 0x00, 0x14,
1062             0x00, 0x00, 0x00, 0x05,
1063             /* vendor-information TLV */
1064             0x00, 0x07, 0x00, 0x08,
1065             /* enterprise number */
1066             0x00, 0x00, 0x00, 0x00,
1067             /* enterprise specific information */
1068             0x00, 0x00, 0x00, 0x05
1069         };
1070         final PCEPCloseObjectParser parser = new PCEPCloseObjectParser(this.tlvRegistry, this.viTlvRegistry);
1071         final ByteBuf result = Unpooled.wrappedBuffer(closeBytes);
1072
1073         final TestEnterpriseSpecificInformation esInfo = new TestEnterpriseSpecificInformation(5);
1074         final VendorInformationTlv viTlv = new VendorInformationTlvBuilder().setEnterpriseNumber(new EnterpriseNumber(0L))
1075                 .setEnterpriseSpecificInformation(esInfo).build();
1076         final CCloseBuilder builder = new CCloseBuilder();
1077         builder.setProcessingRule(false);
1078         builder.setIgnore(false);
1079         builder.setReason((short) 5);
1080         builder.setTlvs(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.close.object.c.close.TlvsBuilder()
1081             .setVendorInformationTlv(Lists.newArrayList(viTlv)).build());
1082
1083         assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(false, false), result.slice(4, result.readableBytes() - 4)));
1084
1085         final ByteBuf buf = Unpooled.buffer();
1086         parser.serializeObject(builder.build(), buf);
1087         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
1088     }
1089
1090     @Test
1091     public void testVendorInformationObject() throws PCEPDeserializerException {
1092         final byte[] viObjBytes = {
1093             /* vendor-information object */
1094             0x22, 0x10, 0x00, 0x0C,
1095             /* enterprise number */
1096             0x00, 0x00, 0x00, 0x00,
1097             /* enterprise specific information */
1098             0x00, 0x00, 0x00, 0x05
1099         };
1100         final TestVendorInformationObjectParser parser = new TestVendorInformationObjectParser();
1101         final TestEnterpriseSpecificInformation esInfo = new TestEnterpriseSpecificInformation(5);
1102         final VendorInformationObject viObj = new VendorInformationObjectBuilder().setEnterpriseNumber(new EnterpriseNumber(0L))
1103                 .setEnterpriseSpecificInformation(esInfo).build();
1104         final ByteBuf result = Unpooled.wrappedBuffer(viObjBytes);
1105         result.readerIndex(8);
1106         final VendorInformationObject o = (VendorInformationObject) parser.parseObject(new ObjectHeaderImpl(false, false), result.readSlice(result.readableBytes()));
1107         assertEquals(viObj, o);
1108
1109         final ByteBuf buf = Unpooled.buffer(viObjBytes.length);
1110         parser.serializeObject(viObj, buf);
1111         assertArrayEquals(result.array(), ByteArray.getAllBytes(buf));
1112     }
1113
1114     @Test
1115     public void testMonitoringObject() throws PCEPDeserializerException {
1116         final byte[] monitoringBytes = {
1117             /* object header */
1118             0x13, 0x10, 0x00, 0x0C,
1119             /* flags */
1120             0x00, 0x00, 0x00, 0x01,
1121             /* monitoring-id=16 */
1122             0x00, 0x00, 0x00, 0x10
1123         };
1124         final PCEPMonitoringObjectParser parser = new PCEPMonitoringObjectParser(this.tlvRegistry, this.viTlvRegistry);
1125         final Monitoring monitoring = new MonitoringBuilder().setMonitoringId(16L).setFlags(new Flags(false, false, true, false, false)).setTlvs(
1126                 new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.monitoring.object.monitoring.TlvsBuilder().build()).build();
1127         final ByteBuf result = Unpooled.wrappedBuffer(monitoringBytes);
1128         assertEquals(monitoring, parser.parseObject(new ObjectHeaderImpl(false, false), result.slice(4, result.readableBytes() - 4)));
1129
1130         final ByteBuf buf = Unpooled.buffer(monitoringBytes.length);
1131         parser.serializeObject(monitoring, buf);
1132         assertArrayEquals(monitoringBytes, buf.array());
1133     }
1134
1135     @Test
1136     public void testPccIdReqIPv4Object() throws PCEPDeserializerException {
1137         final byte[] pccIdReqBytes = {
1138             /* object header */
1139             0x14, 0x10, 0x00, 0x08,
1140             /* ipv4 address */
1141             0x7f, 0x00, 0x00, 0x01
1142         };
1143         final PCEPPccIdReqIPv4ObjectParser parser = new PCEPPccIdReqIPv4ObjectParser();
1144         final PccIdReq pccIdReq = new PccIdReqBuilder().setIpAddress(new IpAddress(new Ipv4Address("127.0.0.1"))).build();
1145         final ByteBuf result = Unpooled.wrappedBuffer(pccIdReqBytes);
1146         assertEquals(pccIdReq, parser.parseObject(new ObjectHeaderImpl(false, false), result.slice(4, result.readableBytes() - 4)));
1147
1148         final ByteBuf buf = Unpooled.buffer(pccIdReqBytes.length);
1149         parser.serializeObject(pccIdReq, buf);
1150         assertArrayEquals(pccIdReqBytes, buf.array());
1151     }
1152
1153     @Test
1154     public void testPccIdReqIPv6Object() throws PCEPDeserializerException {
1155         final byte[] pccIdReqBytes = {
1156             /* object header */
1157             0x14, 0x20, 0x00, 0x14,
1158             /* ipv6 address */
1159             0x00, 0x00, 0x00, 0x00,
1160             0x00, 0x00, 0x00, 0x00,
1161             0x00, 0x00, 0x00, 0x00,
1162             0x00, 0x00, 0x00, 0x01
1163         };
1164         final PCEPPccIdReqIPv6ObjectParser parser = new PCEPPccIdReqIPv6ObjectParser();
1165         final PccIdReq pccIdReq = new PccIdReqBuilder().setIpAddress(new IpAddress(new Ipv6Address("::1"))).build();
1166         final ByteBuf result = Unpooled.wrappedBuffer(pccIdReqBytes);
1167         assertEquals(pccIdReq, parser.parseObject(new ObjectHeaderImpl(false, false), result.slice(4, result.readableBytes() - 4)));
1168
1169         final ByteBuf buf = Unpooled.buffer(pccIdReqBytes.length);
1170         parser.serializeObject(pccIdReq, buf);
1171         assertArrayEquals(pccIdReqBytes, buf.array());
1172     }
1173
1174     @Test
1175     public void testPceIdIPv4Object() throws PCEPDeserializerException {
1176         final byte[] pccIdReqBytes = {
1177             /* object header */
1178             0x19, 0x10, 0x00, 0x08,
1179             /* ipv4 address */
1180             0x7f, 0x00, 0x00, 0x01
1181         };
1182         final PCEPPceIdIPv4ObjectParser parser = new PCEPPceIdIPv4ObjectParser();
1183         final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pce.id.object.PceId pceId = new PceIdBuilder().setIpAddress(new IpAddress(
1184                 new Ipv4Address("127.0.0.1"))).build();
1185         final ByteBuf result = Unpooled.wrappedBuffer(pccIdReqBytes);
1186         assertEquals(pceId, parser.parseObject(new ObjectHeaderImpl(false, false), result.slice(4, result.readableBytes() - 4)));
1187
1188         final ByteBuf buf = Unpooled.buffer(pccIdReqBytes.length);
1189         parser.serializeObject(pceId, buf);
1190         assertArrayEquals(pccIdReqBytes, buf.array());
1191     }
1192
1193     @Test
1194     public void testPceIdIPv6Object() throws PCEPDeserializerException {
1195         final byte[] pccIdReqBytes = {
1196             /* object header */
1197             0x19, 0x20, 0x00, 0x14,
1198             /* ipv6 header */
1199             0x00, 0x00, 0x00, 0x00,
1200             0x00, 0x00, 0x00, 0x00,
1201             0x00, 0x00, 0x00, 0x00,
1202             0x00, 0x00, 0x00, 0x01
1203         };
1204         final PCEPPceIdIPv6ObjectParser parser = new PCEPPceIdIPv6ObjectParser();
1205         final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pce.id.object.PceId pccIdReq = new PceIdBuilder().setIpAddress(new IpAddress(
1206                 new Ipv6Address("::1"))).build();
1207         final ByteBuf result = Unpooled.wrappedBuffer(pccIdReqBytes);
1208         assertEquals(pccIdReq, parser.parseObject(new ObjectHeaderImpl(false, false), result.slice(4, result.readableBytes() - 4)));
1209
1210         final ByteBuf buf = Unpooled.buffer(pccIdReqBytes.length);
1211         parser.serializeObject(pccIdReq, buf);
1212         assertArrayEquals(pccIdReqBytes, buf.array());
1213     }
1214
1215     @Test
1216     public void testProcTimeObject() throws PCEPDeserializerException {
1217         final byte[] proctimeBytes = {
1218             /* object header */
1219             0x1A, 0x10, 0x00, 0x1C,
1220             /* E flag */
1221             0x00, 0x00, 0x00, 0x01,
1222             /* current proc. time */
1223             0x00, 0x00, 0x00, 0x01,
1224             /* min proc. time */
1225             0x00, 0x00, 0x00, 0x02,
1226             /* max proc time */
1227             0x00, 0x00, 0x00, 0x03,
1228             /* average proc time */
1229             0x00, 0x00, 0x00, 0x04,
1230             /* variance proc time */
1231             0x00, 0x00, 0x00, 0x05,
1232         };
1233         final PCEPProcTimeObjectParser parser = new PCEPProcTimeObjectParser();
1234         final ProcTime procTime = new ProcTimeBuilder()
1235             .setEstimated(true)
1236             .setAverageProcTime(4L)
1237             .setCurrentProcTime(1L)
1238             .setMaxProcTime(3L)
1239             .setMinProcTime(2L)
1240             .setVarianceProcTime(5L).build();
1241         final ByteBuf result = Unpooled.wrappedBuffer(proctimeBytes);
1242         assertEquals(procTime, parser.parseObject(new ObjectHeaderImpl(false, false), result.slice(4, result.readableBytes() - 4)));
1243
1244         final ByteBuf buf = Unpooled.buffer(proctimeBytes.length);
1245         parser.serializeObject(procTime, buf);
1246         assertArrayEquals(proctimeBytes, buf.array());
1247     }
1248
1249     @Test
1250     public void testOverloadObject() throws PCEPDeserializerException {
1251         final byte[] overloadBytes = {
1252             /* object header */
1253             0x1B, 0x10, 0x00, 0x08,
1254             /* overload duration */
1255             0x00, 0x00, 0x00, 0x78
1256         };
1257         final PCEPOverloadObjectParser parser = new PCEPOverloadObjectParser();
1258         final Overload overload = new OverloadBuilder().setDuration(120).build();
1259         final ByteBuf result = Unpooled.wrappedBuffer(overloadBytes);
1260         assertEquals(overload, parser.parseObject(new ObjectHeaderImpl(false, false), result.slice(4, result.readableBytes() - 4)));
1261
1262         final ByteBuf buf = Unpooled.buffer(overloadBytes.length);
1263         parser.serializeObject(overload, buf);
1264         assertArrayEquals(overloadBytes, buf.array());
1265     }
1266
1267     @Test
1268     public void testRpObjectWithPstTlvParser() throws PCEPDeserializerException {
1269
1270         final byte[] rpObjectWithPstTlvBytes = { 0x2, 0x10, 0x0, 0x14, 0x0, 0x0, 0x4, 0x2d, (byte) 0xde,
1271             (byte) 0xad, (byte) 0xbe, (byte) 0xef,
1272             /* pst-tlv */
1273             0x0, 0x1C, 0x0, 0x4, 0x0, 0x0, 0x0, 0x0 };
1274
1275         final PCEPRequestParameterObjectParser parser = new PCEPRequestParameterObjectParser(this.tlvRegistry, this.viTlvRegistry);
1276         final RpBuilder builder = new RpBuilder();
1277         builder.setProcessingRule(false);
1278         builder.setIgnore(false);
1279         builder.setReoptimization(true);
1280         builder.setBiDirectional(false);
1281         builder.setLoose(true);
1282         builder.setMakeBeforeBreak(true);
1283         builder.setOrder(false);
1284         builder.setPathKey(false);
1285         builder.setSupplyOf(false);
1286         builder.setFragmentation(false);
1287         builder.setP2mp(false);
1288         builder.setEroCompression(false);
1289         builder.setPriority((short) 5);
1290         builder.setRequestId(new RequestId(0xdeadbeefL));
1291         builder.setTlvs(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.rp.object.rp.TlvsBuilder().setPathSetupType(
1292                 new PathSetupTypeBuilder().setPst((short) 0).build()).build());
1293
1294         final ByteBuf result = Unpooled.wrappedBuffer(rpObjectWithPstTlvBytes);
1295         assertEquals(builder.build(),
1296                 parser.parseObject(new ObjectHeaderImpl(false, false), result.slice(4, result.readableBytes() - 4)));
1297         final ByteBuf buf = Unpooled.buffer();
1298         parser.serializeObject(builder.build(), buf);
1299         assertArrayEquals(rpObjectWithPstTlvBytes, ByteArray.getAllBytes(buf));
1300     }
1301 }