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
  13 import java.io.IOException;
  14 import java.util.List;
  15
  16 import org.junit.Before;
  17 import org.junit.Test;
  18 import org.opendaylight.protocol.concepts.Ipv4Util;
  19 import org.opendaylight.protocol.concepts.Ipv6Util;
  20 import org.opendaylight.protocol.pcep.PCEPDeserializerException;
  21 import org.opendaylight.protocol.pcep.PCEPDocumentedException;
  22 import org.opendaylight.protocol.pcep.impl.object.PCEPBandwidthObjectParser;
  23 import org.opendaylight.protocol.pcep.impl.object.PCEPClassTypeObjectParser;
  24 import org.opendaylight.protocol.pcep.impl.object.PCEPCloseObjectParser;
  25 import org.opendaylight.protocol.pcep.impl.object.PCEPEndPointsObjectParser;
  26 import org.opendaylight.protocol.pcep.impl.object.PCEPErrorObjectParser;
  27 import org.opendaylight.protocol.pcep.impl.object.PCEPGlobalConstraintsObjectParser;
  28 import org.opendaylight.protocol.pcep.impl.object.PCEPLoadBalancingObjectParser;
  29 import org.opendaylight.protocol.pcep.impl.object.PCEPLspaObjectParser;
  30 import org.opendaylight.protocol.pcep.impl.object.PCEPMetricObjectParser;
  31 import org.opendaylight.protocol.pcep.impl.object.PCEPNotificationObjectParser;
  32 import org.opendaylight.protocol.pcep.impl.object.PCEPObjectiveFunctionObjectParser;
  33 import org.opendaylight.protocol.pcep.impl.object.PCEPSrpObjectParser;
  34 import org.opendaylight.protocol.pcep.impl.object.PCEPSvecObjectParser;
  35 import org.opendaylight.protocol.pcep.spi.ObjectHeaderImpl;
  36 import org.opendaylight.protocol.pcep.spi.TlvHandlerRegistry;
  37 import org.opendaylight.protocol.pcep.spi.pojo.PCEPExtensionProviderContextImpl;
  38 import org.opendaylight.protocol.util.ByteArray;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ieee754.rev130819.Float32;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.ClassType;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.NotificationObject;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.OfId;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.RequestId;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.SrpIdNumber;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.close.message.c.close.message.CCloseBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.endpoints.object.address.family.Ipv4Builder;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.endpoints.object.address.family.Ipv6Builder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.lsp.attributes.ClassTypeBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.lsp.attributes.LspaBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.lsp.attributes.OfBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.overload.duration.tlv.OverloadDurationBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcep.error.object.TlvsBuilder;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcerr.message.pcerr.message.ErrorsBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcinitiate.message.pcinitiate.message.requests.EndpointsBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcinitiate.message.pcinitiate.message.requests.SrpBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcntf.message.pcntf.message.notifications.NotificationsBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcreq.message.pcreq.message.SvecBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcreq.message.pcreq.message.requests.segment.computation.p2p.LoadBalancingBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcreq.message.pcreq.message.requests.segment.computation.p2p.reported.route.BandwidthBuilder;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcreq.message.pcreq.message.svec.GcBuilder;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcreq.message.pcreq.message.svec.MetricBuilder;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.req.missing.tlv.ReqMissingBuilder;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev130820.AttributeFilter;
  64
  65 import com.google.common.collect.Lists;
  66 import com.google.common.primitives.UnsignedBytes;
  67
  68 public class PCEPObjectParserTest {
  69
  70         private TlvHandlerRegistry tlvRegistry;
  71
  72         @Before
  73         public void setUp() throws Exception {
  74                 this.tlvRegistry = PCEPExtensionProviderContextImpl.create().getTlvHandlerRegistry();
  75         }
  76
  77         // @Test
  78         // @Ignore
  79         // // FIXME: temporary
  80         // public void testObjectDeserialization() throws PCEPDeserializerException, IOException, PCEPDocumentedException {
  81         // PCEPObjectFactory.parseObjects(ByteArray.fileToBytes("src/test/resources/PCEPOpenObject1.bin"));
  82         // }
  83         //
  84         // @Test
  85         // public void testUnknownClass() throws PCEPDeserializerException, IOException, PCEPDocumentedException {
  86         //
  87         // final PCEPObject obj =
  88         // PCEPObjectFactory.parseObjects(ByteArray.fileToBytes("src/test/resources/PCEPObject1UnknownClass.bin")).get(
  89         // 0);
  90         //
  91         // // assertTrue(obj instanceof UnknownObject);
  92         // // assertEquals(((UnknownObject) obj).getError(), PCEPErrors.UNRECOGNIZED_OBJ_CLASS);
  93         // }
  94         //
  95         // // @Test
  96         // // public void testUnknownType() throws PCEPDeserializerException, IOException, PCEPDocumentedException {
  97         // // final PCEPObject obj =
  98         // PCEPObjectFactory.parseObjects(ByteArray.fileToBytes("src/test/resources/PCEPObject2UnknownType.bin")).get(0);
  99         // //
 100         // // assertTrue(obj instanceof UnknownObject);
 101         // // assertEquals(((UnknownObject) obj).getError(), PCEPErrors.UNRECOGNIZED_OBJ_TYPE);
 102         // // }
 103         // //
 104
 105         @Test
 106         public void testCloseObject() throws IOException, PCEPDeserializerException, PCEPDocumentedException {
 107                 final PCEPCloseObjectParser parser = new PCEPCloseObjectParser(this.tlvRegistry);
 108                 final byte[] result = ByteArray.fileToBytes("src/test/resources/PCEPCloseObject1.bin");
 109
 110                 final CCloseBuilder builder = new CCloseBuilder();
 111                 builder.setProcessingRule(false);
 112                 builder.setIgnore(false);
 113                 builder.setReason((short) 5);
 114
 115                 assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(false, false), result));
 116                 assertArrayEquals(result, parser.serializeObject(builder.build()));
 117         }
 118
 119         @Test
 120         public void testLoadBalancingObject() throws IOException, PCEPDeserializerException, PCEPDocumentedException {
 121                 final PCEPLoadBalancingObjectParser parser = new PCEPLoadBalancingObjectParser(this.tlvRegistry);
 122                 final byte[] result = ByteArray.fileToBytes("src/test/resources/PCEPLoadBalancingObject1.bin");
 123
 124                 final LoadBalancingBuilder builder = new LoadBalancingBuilder();
 125                 builder.setProcessingRule(true);
 126                 builder.setIgnore(false);
 127                 builder.setMaxLsp((short) UnsignedBytes.toInt((byte) 0xf1));
 128                 builder.setMinBandwidth(new Float32(new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF }));
 129
 130                 assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, false), result));
 131                 assertArrayEquals(result, parser.serializeObject(builder.build()));
 132         }
 133
 134         //
 135         // @Test
 136         // public void testLspObjectSerDeser() throws IOException, PCEPDeserializerException, PCEPDocumentedException {
 137         // serDeserTest("src/test/resources/PCEPLspObject1NoTlvsUpperBounds.bin", new PCEPLspObject(0xFFFFF, true, false,
 138         // true, false, null));
 139         // }
 140         //
 141         // @Test
 142         // public void testERObjectSerDeser() throws IOException, PCEPDeserializerException, PCEPDocumentedException {
 143         // final byte[] bytesFromFile =
 144         // ByteArray.fileToBytes("src/test/resources/PCEPExplicitRouteObject1PackOfSubobjects.bin");
 145         //
 146         // MockitoAnnotations.initMocks(this);
 147         // PCEPExplicitRouteObjectParser parser = new PCEPExplicitRouteObjectParser(registry);
 148         // doReturn(parser).when(registry).getObjectParser(PCEPExplicitRouteObjectParser.TYPE,
 149         // PCEPExplicitRouteObjectParser.CLASS);
 150         // doReturn(new EROAsNumberSubobjectParser()).when(registry).getSubobjectParser(EROAsNumberSubobjectParser.TYPE);
 151         // ObjectHeader h = new ObjectHeader() {
 152         //
 153         // @Override
 154         // public Class<? extends DataContainer> getImplementedInterface() {
 155         // // TODO Auto-generated method stub
 156         // return null;
 157         // }
 158         //
 159         // @Override
 160         // public Boolean isProcessingRule() {
 161         // return false;
 162         // }
 163         //
 164         // @Override
 165         // public Boolean isIgnore() {
 166         // return false;
 167         // }
 168         // };
 169         //
 170         // final ExplicitRouteSubobject specObj = (ExplicitRouteSubobject)
 171         // registry.getObjectParser(PCEPExplicitRouteObjectParser.TYPE, PCEPExplicitRouteObjectParser.CLASS).parseObject(h,
 172         // bytesFromFile);
 173         //
 174         // System.out.println(specObj.toString());
 175         //
 176         // //final byte[] bytesActual = PCEPObjectFactory.put(Arrays.asList((PCEPObject) specObj));
 177         // //assertArrayEquals(bytesFromFile, bytesActual);
 178         // }
 179         //
 180         // @Test
 181         // public void testIRObjectSerDeser() throws IOException, PCEPDeserializerException, PCEPDocumentedException {
 182         // final byte[] bytesFromFile =
 183         // ByteArray.fileToBytes("src/test/resources/PCEPIncludeRouteObject1PackOfSubobjects.bin");
 184         //
 185         // final PCEPIncludeRouteObject specObj = (PCEPIncludeRouteObject)
 186         // PCEPObjectFactory.parseObjects(bytesFromFile).get(0);
 187         //
 188         // assertEquals(8, specObj.getSubobjects().size());
 189         //
 190         // final byte[] bytesActual = PCEPObjectFactory.put(Arrays.asList((PCEPObject) specObj));
 191         // assertArrayEquals(bytesFromFile, bytesActual);
 192         // }
 193         //
 194         // @Test
 195         // public void tesRRObjectSerDeser() throws IOException, PCEPDeserializerException, PCEPDocumentedException {
 196         // final byte[] bytesFromFile =
 197         // ByteArray.fileToBytes("src/test/resources/PCEPReportedRouteObject1PackOfSubobjects.bin");
 198         //
 199         // final PCEPReportedRouteObject specObj = (PCEPReportedRouteObject)
 200         // PCEPObjectFactory.parseObjects(bytesFromFile).get(0);
 201         //
 202         // assertEquals(6, specObj.getSubobjects().size());
 203         //
 204         // final byte[] bytesActual = PCEPObjectFactory.put(Arrays.asList((PCEPObject) specObj));
 205         // assertArrayEquals(bytesFromFile, bytesActual);
 206         // }
 207         //
 208
 209         @Test
 210         public void testBandwidthObject() throws IOException, PCEPDeserializerException, PCEPDocumentedException {
 211                 final PCEPBandwidthObjectParser parser = new PCEPBandwidthObjectParser(this.tlvRegistry);
 212                 byte[] result = ByteArray.fileToBytes("src/test/resources/PCEPBandwidthObject1LowerBounds.bin");
 213
 214                 final BandwidthBuilder builder = new BandwidthBuilder();
 215                 builder.setProcessingRule(true);
 216                 builder.setIgnore(true);
 217                 builder.setBandwidth(new Float32(result));
 218
 219                 assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result));
 220                 assertArrayEquals(result, parser.serializeObject(builder.build()));
 221
 222                 result = ByteArray.fileToBytes("src/test/resources/PCEPBandwidthObject2UpperBounds.bin");
 223
 224                 builder.setBandwidth(new Float32(result));
 225
 226                 assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result));
 227                 assertArrayEquals(result, parser.serializeObject(builder.build()));
 228         }
 229
 230         @Test
 231         public void testEndPointsObjectIPv4() throws IOException, PCEPDeserializerException, PCEPDocumentedException {
 232                 final byte[] srcIPBytes = { (byte) 0xA2, (byte) 0xF5, (byte) 0x11, (byte) 0x0E };
 233                 final byte[] destIPBytes = { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF };
 234
 235                 final PCEPEndPointsObjectParser parser = new PCEPEndPointsObjectParser(this.tlvRegistry);
 236                 final byte[] result = ByteArray.fileToBytes("src/test/resources/PCEPEndPointsObject1IPv4.bin");
 237
 238                 final EndpointsBuilder builder = new EndpointsBuilder();
 239                 builder.setProcessingRule(true);
 240                 builder.setIgnore(false);
 241                 builder.setAddressFamily(new Ipv4Builder().setSourceIpv4Address(Ipv4Util.addressForBytes(srcIPBytes)).setDestinationIpv4Address(
 242                                 Ipv4Util.addressForBytes(destIPBytes)).build());
 243
 244                 assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, false), result));
 245                 assertArrayEquals(result, parser.serializeObject(builder.build()));
 246         }
 247
 248         @Test
 249         public void testEndPointsObjectIPv6() throws IOException, PCEPDeserializerException, PCEPDocumentedException {
 250                 final byte[] destIPBytes = { (byte) 0x00, (byte) 0x02, (byte) 0x5D, (byte) 0xD2, (byte) 0xFF, (byte) 0xEC, (byte) 0xA1,
 251                                 (byte) 0xB6, (byte) 0x58, (byte) 0x1E, (byte) 0x9F, (byte) 0x50, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, };
 252                 final byte[] srcIPBytes = { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
 253                                 (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF };
 254
 255                 final PCEPEndPointsObjectParser parser = new PCEPEndPointsObjectParser(this.tlvRegistry);
 256                 final byte[] result = ByteArray.fileToBytes("src/test/resources/PCEPEndPointsObject2IPv6.bin");
 257
 258                 final EndpointsBuilder builder = new EndpointsBuilder();
 259                 builder.setProcessingRule(true);
 260                 builder.setIgnore(false);
 261                 builder.setAddressFamily(new Ipv6Builder().setSourceIpv6Address(Ipv6Util.addressForBytes(srcIPBytes)).setDestinationIpv6Address(
 262                                 Ipv6Util.addressForBytes(destIPBytes)).build());
 263
 264                 assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, false), result));
 265                 assertArrayEquals(result, parser.serializeObject(builder.build()));
 266         }
 267
 268         @Test
 269         public void testErrorObjectWithTlv() throws PCEPDeserializerException, IOException, PCEPDocumentedException {
 270                 final PCEPErrorObjectParser parser = new PCEPErrorObjectParser(this.tlvRegistry);
 271                 byte[] result = ByteArray.fileToBytes("src/test/resources/PCEPErrorObject1.bin");
 272
 273                 final ErrorsBuilder builder = new ErrorsBuilder();
 274                 builder.setProcessingRule(true);
 275                 builder.setIgnore(true);
 276                 builder.setType((short) 1);
 277                 builder.setValue((short) 1);
 278
 279                 assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result));
 280                 assertArrayEquals(result, parser.serializeObject(builder.build()));
 281
 282                 result = ByteArray.fileToBytes("src/test/resources/PCEPErrorObject3.bin");
 283
 284                 builder.setType((short) 7);
 285                 builder.setValue((short) 0);
 286                 builder.setTlvs(new TlvsBuilder().setReqMissing(new ReqMissingBuilder().setRequestId(new RequestId(0x00001155L)).build()).build());
 287
 288                 assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result));
 289                 assertArrayEquals(result, parser.serializeObject(builder.build()));
 290         }
 291
 292         @Test
 293         public void testLspaObject() throws IOException, PCEPDeserializerException, PCEPDocumentedException {
 294                 final PCEPLspaObjectParser parser = new PCEPLspaObjectParser(this.tlvRegistry);
 295                 byte[] result = ByteArray.fileToBytes("src/test/resources/PCEPLspaObject1LowerBounds.bin");
 296
 297                 final LspaBuilder builder = new LspaBuilder();
 298                 builder.setProcessingRule(true);
 299                 builder.setIgnore(true);
 300                 builder.setExcludeAny(new AttributeFilter(0L));
 301                 builder.setIncludeAny(new AttributeFilter(0L));
 302                 builder.setIncludeAll(new AttributeFilter(0L));
 303                 builder.setHoldPriority((short) 0);
 304                 builder.setSetupPriority((short) 0);
 305                 builder.setLocalProtectionDesired(false);
 306
 307                 assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result));
 308                 assertArrayEquals(result, parser.serializeObject(builder.build()));
 309
 310                 result = ByteArray.fileToBytes("src/test/resources/PCEPLspaObject2UpperBounds.bin");
 311
 312                 builder.setExcludeAny(new AttributeFilter(0xFFFFFFFFL));
 313                 builder.setIncludeAny(new AttributeFilter(0xFFFFFFFFL));
 314                 builder.setIncludeAll(new AttributeFilter(0xFFFFFFFFL));
 315                 builder.setHoldPriority((short) 0xFF);
 316                 builder.setSetupPriority((short) 0xFF);
 317                 builder.setLocalProtectionDesired(true);
 318
 319                 assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result));
 320                 assertArrayEquals(result, parser.serializeObject(builder.build()));
 321
 322                 result = ByteArray.fileToBytes("src/test/resources/PCEPLspaObject3RandVals.bin");
 323
 324                 builder.setExcludeAny(new AttributeFilter(0x20A1FEE3L));
 325                 builder.setIncludeAny(new AttributeFilter(0x1A025CC7L));
 326                 builder.setIncludeAll(new AttributeFilter(0x2BB66532L));
 327                 builder.setHoldPriority((short) 0x02);
 328                 builder.setSetupPriority((short) 0x03);
 329                 builder.setLocalProtectionDesired(true);
 330
 331                 assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result));
 332                 assertArrayEquals(result, parser.serializeObject(builder.build()));
 333         }
 334
 335         @Test
 336         public void testMetricObject() throws IOException, PCEPDeserializerException, PCEPDocumentedException {
 337                 final PCEPMetricObjectParser parser = new PCEPMetricObjectParser(this.tlvRegistry);
 338                 byte[] result = ByteArray.fileToBytes("src/test/resources/PCEPMetricObject1LowerBounds.bin");
 339
 340                 final MetricBuilder builder = new MetricBuilder();
 341                 builder.setProcessingRule(true);
 342                 builder.setIgnore(true);
 343                 builder.setComputed(false);
 344                 builder.setBound(false);
 345                 builder.setMetricType((short) 1);
 346                 builder.setValue(new Float32(new byte[] { 0, 0, 0, 0 }));
 347
 348                 assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result));
 349                 assertArrayEquals(result, parser.serializeObject(builder.build()));
 350
 351                 result = ByteArray.fileToBytes("src/test/resources/PCEPMetricObject2UpperBounds.bin");
 352
 353                 builder.setComputed(true);
 354                 builder.setBound(false);
 355                 builder.setMetricType((short) 2);
 356                 builder.setValue(new Float32(new byte[] { (byte) 0x4f, (byte) 0x70, (byte) 0x00, (byte) 0x00 }));
 357
 358                 assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result));
 359                 assertArrayEquals(result, parser.serializeObject(builder.build()));
 360         }
 361
 362         // @Test
 363         // public void testNoPathObject() throws PCEPDeserializerException, IOException, PCEPDocumentedException {
 364         // final List<PCEPTlv> tlvs = new ArrayList<PCEPTlv>(1);
 365         // tlvs.add(new NoPathVectorTlv(false, false, true, false, false, false));
 366         // serDeserTest("src/test/resources/NoPathObject1WithTLV.bin", new PCEPNoPathObject((short) 2, true, tlvs, false));
 367         // serDeserTest("src/test/resources/NoPathObject2WithoutTLV.bin", new PCEPNoPathObject((short) 0x10, false, true));
 368         //
 369         // byte[] bytesFromFile = ByteArray.fileToBytes("src/test/resources/NoPathObject2WithoutTLV.bin");
 370         // PCEPNoPathObject noPathObject = (PCEPNoPathObject) PCEPObjectFactory.parseObjects(bytesFromFile).get(0);
 371         // byte[] bytesActual = PCEPObjectFactory.put(Arrays.asList((PCEPObject) noPathObject));
 372         // assertArrayEquals(bytesFromFile, bytesActual);
 373         //
 374         // bytesFromFile = ByteArray.fileToBytes("src/test/resources/NoPathObject1WithTLV.bin");
 375         // noPathObject = (PCEPNoPathObject) PCEPObjectFactory.parseObjects(bytesFromFile).get(0);
 376         // bytesActual = PCEPObjectFactory.put(Arrays.asList((PCEPObject) noPathObject));
 377         // assertArrayEquals(bytesFromFile, bytesActual);
 378         // }
 379
 380         @Test
 381         public void testNotifyObjectWithTlv() throws PCEPDeserializerException, IOException, PCEPDocumentedException {
 382                 final PCEPNotificationObjectParser parser = new PCEPNotificationObjectParser(this.tlvRegistry);
 383                 byte[] result = ByteArray.fileToBytes("src/test/resources/PCEPNotificationObject2WithoutTlv.bin");
 384
 385                 final NotificationsBuilder builder = new NotificationsBuilder();
 386                 builder.setProcessingRule(true);
 387                 builder.setIgnore(true);
 388                 builder.setType((short) 0xff);
 389                 builder.setValue((short) 0xff);
 390
 391                 assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result));
 392                 assertArrayEquals(result, parser.serializeObject(builder.build()));
 393
 394                 result = ByteArray.fileToBytes("src/test/resources/PCEPNotificationObject1WithTlv.bin");
 395
 396                 builder.setType((short) 2);
 397                 builder.setValue((short) 1);
 398                 builder.setTlvs(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.notification.object.TlvsBuilder().setOverloadDuration(
 399                                 new OverloadDurationBuilder().setDuration(0xff0000a2L).build()).build());
 400
 401                 final NotificationObject t = parser.parseObject(new ObjectHeaderImpl(true, true), result);
 402                 assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, true), result));
 403                 assertArrayEquals(result, parser.serializeObject(builder.build()));
 404         }
 405
 406         //
 407         // /**
 408         // * Standard ser deser test<br/>
 409         // * used resources:<br/>
 410         // * - PCEPOpenObject1.bin
 411         // *
 412         // * @throws PCEPDeserializerException
 413         // * @throws IOException
 414         // * @throws PCEPDocumentedException
 415         // */
 416         // @Test
 417         // @Ignore
 418         // // FIXME: temporary
 419         // public void testOpenObjectSerDeser() throws PCEPDeserializerException, IOException, PCEPDocumentedException {
 420         // // final List<PCEPTlv> tlvs = new ArrayList<PCEPTlv>();
 421         // // tlvs.add(new PCEStatefulCapabilityTlv(false, true, true));
 422         // // tlvs.add(new LSPStateDBVersionTlv(0x80));
 423         // // final byte[] valueBytes = { (byte) 0x12, (byte) 0x34, (byte) 0x56, (byte) 0x78, (byte) 0x9A, (byte) 0xBC,
 424         // (byte) 0xDE, (byte) 0xF0 };
 425         // // tlvs.add(new NodeIdentifierTlv(valueBytes));
 426         // // final PCEPOpenObject specObject = new PCEPOpenObject(30, 120, 1, tlvs);
 427         // //
 428         // // serDeserTest("src/test/resources/PCEPOpenObject1.bin", specObject);
 429         // }
 430         //
 431         // /**
 432         // * Specific test for upper bounds and without tlvs<br/>
 433         // * Used resources:<br/>
 434         // * - PCEPOpenObject2UpperBoundsNoTlv.bin
 435         // *
 436         // * @throws PCEPDeserializerException
 437         // * @throws IOException
 438         // * @throws PCEPDocumentedException
 439         // */
 440         // @Test
 441         // public void testOpenObjectBoundsWithoutTlvs() throws IOException, PCEPDeserializerException,
 442         // PCEPDocumentedException {
 443         // // final List<PCEPTlv> tlvs = new ArrayList<PCEPTlv>();
 444         // // serDeserTest("src/test/resources/PCEPOpenObject2UpperBoundsNoTlv.bin", new PCEPOpenObject(0xFF, 0xFF, 0xFF,
 445         // tlvs));
 446         // serDeserTest("src/test/resources/PCEPOpenObject2UpperBoundsNoTlv.bin", new PCEPOpenObject(0xFF, 0xFF, 0xFF,
 447         // null));
 448         // }
 449         //
 450         // /**
 451         // * Standard deserialization test<br/>
 452         // * Used resources:<br/>
 453         // * - PCEPRPObject1.bin
 454         // *
 455         // * @throws PCEPDeserializerException
 456         // * @throws IOException
 457         // * @throws PCEPDocumentedException
 458         // */
 459         // @Test
 460         // public void testRPObjectSerDeser() throws PCEPDeserializerException, IOException, PCEPDocumentedException {
 461         // serDeserTest("src/test/resources/PCEPRPObject1.bin",
 462         // new PCEPRequestParameterObject(true, false, true, true, false, false, false, false, (short) 5, 0xdeadbeefL,
 463         // false, false));
 464         // // serDeserTest(
 465         // // "src/test/resources/PCEPRPObject2.bin",
 466         // // new PCEPRequestParameterObject(true, false, false, false, true, false, true, false, true, (short) 5,
 467         // 0xdeadbeefL, new ArrayList<PCEPTlv>() {
 468         // // private static final long serialVersionUID = 1L;
 469         // //
 470         // // {
 471         // // this.add(new OrderTlv(0xFFFFFFFFL, 0x00000001L));
 472         // // }
 473         // // }, false, false));
 474         // }
 475         //
 476
 477         @Test
 478         public void testSvecObject() throws IOException, PCEPDeserializerException, PCEPDocumentedException {
 479                 final PCEPSvecObjectParser parser = new PCEPSvecObjectParser(this.tlvRegistry);
 480                 byte[] result = ByteArray.fileToBytes("src/test/resources/PCEPSvecObject2.bin");
 481
 482                 final SvecBuilder builder = new SvecBuilder();
 483                 builder.setProcessingRule(false);
 484                 builder.setIgnore(false);
 485                 builder.setLinkDiverse(false);
 486                 builder.setNodeDiverse(false);
 487                 builder.setSrlgDiverse(false);
 488                 builder.setRequestsIds(Lists.newArrayList(new RequestId(0xFFL)));
 489
 490                 assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(false, false), result));
 491                 assertArrayEquals(result, parser.serializeObject(builder.build()));
 492
 493                 result = ByteArray.fileToBytes("src/test/resources/PCEPSvecObject1_10ReqIDs.bin");
 494
 495                 builder.setProcessingRule(true);
 496                 builder.setLinkDiverse(true);
 497                 builder.setSrlgDiverse(true);
 498
 499                 final List<RequestId> requestIDs = Lists.newArrayList();
 500                 requestIDs.add(new RequestId(0xFFFFFFFFL));
 501                 requestIDs.add(new RequestId(0x00000000L));
 502                 requestIDs.add(new RequestId(0x01234567L));
 503                 requestIDs.add(new RequestId(0x89ABCDEFL));
 504                 requestIDs.add(new RequestId(0xFEDCBA98L));
 505                 requestIDs.add(new RequestId(0x76543210L));
 506                 requestIDs.add(new RequestId(0x15825266L));
 507                 requestIDs.add(new RequestId(0x48120BBEL));
 508                 requestIDs.add(new RequestId(0x25FB7E52L));
 509                 requestIDs.add(new RequestId(0xB2F2546BL));
 510
 511                 builder.setRequestsIds(requestIDs);
 512
 513                 assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, false), result));
 514                 assertArrayEquals(result, parser.serializeObject(builder.build()));
 515         }
 516
 517         @Test
 518         public void testClassTypeObject() throws PCEPDeserializerException, PCEPDocumentedException {
 519                 final PCEPClassTypeObjectParser parser = new PCEPClassTypeObjectParser(this.tlvRegistry);
 520                 final byte[] result = new byte[] { 0, 0, 0, (byte) 0x04 };
 521
 522                 final ClassTypeBuilder builder = new ClassTypeBuilder();
 523                 builder.setProcessingRule(true);
 524                 builder.setIgnore(false);
 525                 builder.setClassType(new ClassType((short) 4));
 526
 527                 assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, false), result));
 528                 assertArrayEquals(result, parser.serializeObject(builder.build()));
 529         }
 530
 531         //
 532         // /**
 533         // * Test PCEPExcludeRouteObjectObject (Serialization/Deserialization)<br/>
 534         // * Used resources:<br/>
 535         // * - PCEPExcludeRouteObject.1.bin<br/>
 536         // *
 537         // * @throws IOException
 538         // * @throws PCEPDeserializerException
 539         // * @throws PCEPDocumentedException
 540         // */
 541         // @Test
 542         // public void testExcludeRouteObject() throws IOException, PCEPDeserializerException, PCEPDocumentedException {
 543         // final List<ExcludeRouteSubobject> xroSubobjects = new ArrayList<ExcludeRouteSubobject>();
 544         // xroSubobjects.add(new XROIPPrefixSubobject<IPv4Prefix>(new IPv4Prefix(new IPv4Address(new byte[] { (byte) 192,
 545         // (byte) 168,
 546         // (byte) 100, (byte) 100 }), 16), true, XROSubobjectAttribute.NODE));
 547         // xroSubobjects.add(new XROAsNumberSubobject(new AsNumber(0x1234L), false));
 548         //
 549         // }
 550         //
 551
 552         @Test
 553         public void testSrpObject() throws IOException, PCEPDeserializerException, PCEPDocumentedException {
 554                 final PCEPSrpObjectParser parser = new PCEPSrpObjectParser(this.tlvRegistry);
 555                 final byte[] result = new byte[] { 0, 0, 0, 0, 0, 0, 0, (byte) 0x01 };
 556
 557                 final SrpBuilder builder = new SrpBuilder();
 558                 builder.setProcessingRule(false);
 559                 builder.setIgnore(false);
 560                 builder.setOperationId(new SrpIdNumber(1L));
 561
 562                 assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(false, false), result));
 563                 assertArrayEquals(result, parser.serializeObject(builder.build()));
 564         }
 565
 566         @Test
 567         public void testObjectiveFunctionObject() throws IOException, PCEPDeserializerException, PCEPDocumentedException {
 568                 final PCEPObjectiveFunctionObjectParser parser = new PCEPObjectiveFunctionObjectParser(this.tlvRegistry);
 569                 final byte[] result = ByteArray.fileToBytes("src/test/resources/PCEPObjectiveFunctionObject.1.bin");
 570
 571                 final OfBuilder builder = new OfBuilder();
 572                 builder.setProcessingRule(true);
 573                 builder.setIgnore(false);
 574                 builder.setCode(new OfId(4));
 575
 576                 assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, false), result));
 577                 assertArrayEquals(result, parser.serializeObject(builder.build()));
 578         }
 579
 580         @Test
 581         public void testGlobalConstraintsObject() throws IOException, PCEPDeserializerException, PCEPDocumentedException {
 582                 final PCEPGlobalConstraintsObjectParser parser = new PCEPGlobalConstraintsObjectParser(this.tlvRegistry);
 583                 final byte[] result = ByteArray.fileToBytes("src/test/resources/PCEPGlobalConstraintsObject.1.bin");
 584
 585                 final GcBuilder builder = new GcBuilder();
 586                 builder.setProcessingRule(true);
 587                 builder.setIgnore(false);
 588                 builder.setMaxHop((short) 1);
 589                 builder.setMaxUtilization((short) 0);
 590                 builder.setMinUtilization((short) 100);
 591                 builder.setOverBookingFactor((short) 0xFF);
 592
 593                 assertEquals(builder.build(), parser.parseObject(new ObjectHeaderImpl(true, false), result));
 594                 assertArrayEquals(result, parser.serializeObject(builder.build()));
 595         }
 596
 597         // // FIXME: add at least one test with true value
 598         // @Test
 599         // public void openObjectWithTlv() throws PCEPDeserializerException, PCEPDocumentedException {
 600         // // this.testOpenObjectWithSpecTlv(new PCEStatefulCapabilityTlv(false, false, false));
 601         // // this.testOpenObjectWithSpecTlv(new PCEStatefulCapabilityTlv(false, false, true));
 602         // // this.testOpenObjectWithSpecTlv(new PCEStatefulCapabilityTlv(false, true, false));
 603         // // this.testOpenObjectWithSpecTlv(new PCEStatefulCapabilityTlv(false, true, true));
 604         // }
 605         //
 606         // // private void testOpenObjectWithSpecTlv(final PCEPTlv tlv) throws PCEPDeserializerException,
 607         // PCEPDocumentedException {
 608         // // final List<PCEPObject> objs = new ArrayList<PCEPObject>();
 609         // // final List<PCEPTlv> tlvs = new ArrayList<PCEPTlv>();
 610         // // tlvs.add(tlv);
 611         // // final PCEPOpenObject oo = new PCEPOpenObject(30, 120, 0, tlvs);
 612         // // objs.add(oo);
 613         // // final byte[] bytes = PCEPObjectFactory.put(objs);
 614         // // final PCEPObject obj = PCEPObjectFactory.parseObjects(bytes).get(0);
 615         // // assertEquals(oo, obj);
 616         // // }
 617         //
 618         // @Test
 619         // public void testErrorsMapping() {
 620         // final PCEPErrorObjectParser.PCEPErrorsMaping mapper = PCEPErrorObjectParser.PCEPErrorsMaping.getInstance();
 621         //
 622         // for (final PCEPErrors error : PCEPErrors.values()) {
 623         // final PCEPErrorIdentifier errorId = mapper.getFromErrorsEnum(error);
 624         // assertEquals(error, mapper.getFromErrorIdentifier(errorId));
 625         // }
 626         // }
 627         //
 628         // @Test
 629         // public void testOFCodesMapping() {
 630         // final PCEPOFCodesMapping mapper = PCEPOFCodesMapping.getInstance();
 631         //
 632         // for (final PCEPOFCodes ofCode : PCEPOFCodes.values()) {
 633         // final int ofCodeId = mapper.getFromOFCodesEnum(ofCode);
 634         // assertEquals(ofCode, mapper.getFromCodeIdentifier(ofCodeId));
 635         // }
 636         // }
 637         //
 638         // @SuppressWarnings("unchecked")
 639         // private static <T extends PCEPObject> void serDeserTestWithoutBin(final T object) throws
 640         // PCEPDeserializerException,
 641         // PCEPDocumentedException {
 642         // final byte[] serBytes = PCEPObjectFactory.put(Arrays.asList((PCEPObject) object));
 643         // final T deserObj = (T) PCEPObjectFactory.parseObjects(serBytes).get(0);
 644         //
 645         // assertEquals(object, deserObj);
 646         // }
 647         //
 648         // @Test
 649         // public void testSERObjects() throws PCEPDocumentedException, PCEPDeserializerException {
 650         // final List<ExplicitRouteSubobject> eroSubobjects = new ArrayList<ExplicitRouteSubobject>();
 651         // eroSubobjects.add(new EROIPPrefixSubobject<IPv4Prefix>(new IPv4Prefix(new IPv4Address(new byte[] { (byte) 192,
 652         // (byte) 168, 1, 8 }), 16), false));
 653         // eroSubobjects.add(new EROIPPrefixSubobject<IPv6Prefix>(new IPv6Prefix(new IPv6Address(new byte[] { (byte) 192,
 654         // (byte) 168, 2, 1,
 655         // (byte) 192, (byte) 168, 2, 1, (byte) 192, (byte) 168, 2, 1, (byte) 192, (byte) 168, 2, 1 }), 64), false));
 656         //
 657         // serDeserTestWithoutBin(new PCEPSecondaryExplicitRouteObject(eroSubobjects, true, false));
 658         // }
 659         //
 660         // @Test
 661         // public void testSRRObject() throws PCEPDocumentedException, PCEPDeserializerException {
 662         // final List<ReportedRouteSubobject> rroSubobjects = new ArrayList<ReportedRouteSubobject>();
 663         // rroSubobjects.add(new RROIPAddressSubobject<IPv4Prefix>(new IPv4Prefix(this.ipv4addr, 16), true, false));
 664         // rroSubobjects.add(new RROIPAddressSubobject<IPv6Prefix>(new IPv6Prefix(this.ipv6addr, 64), false, true));
 665         //
 666         // serDeserTestWithoutBin(new PCEPSecondaryRecordRouteObject(rroSubobjects, true, false));
 667         // }
 668         //
 669         // @Test
 670         // public void testP2MPEndpointsObjects() throws PCEPDeserializerException, PCEPDocumentedException {
 671         // serDeserTestWithoutBin(new PCEPP2MPEndPointsObject<IPv4Address>(2, this.ipv4addr, Arrays.asList(this.ipv4addr,
 672         // this.ipv4addr,
 673         // this.ipv4addr), true, false));
 674         // serDeserTestWithoutBin(new PCEPP2MPEndPointsObject<IPv4Address>(1, this.ipv4addr, Arrays.asList(this.ipv4addr),
 675         // true, false));
 676         // serDeserTestWithoutBin(new PCEPP2MPEndPointsObject<IPv6Address>(2, this.ipv6addr, Arrays.asList(this.ipv6addr,
 677         // this.ipv6addr,
 678         // this.ipv6addr), true, false));
 679         // serDeserTestWithoutBin(new PCEPP2MPEndPointsObject<IPv6Address>(1, this.ipv6addr, Arrays.asList(this.ipv6addr),
 680         // true, false));
 681         // }
 682         //
 683         // @Test
 684         // public void testUnreachedDestinationObjects() throws PCEPDeserializerException, PCEPDocumentedException {
 685         // serDeserTestWithoutBin(new PCEPUnreachedDestinationObject<IPv4Address>(Arrays.asList(this.ipv4addr,
 686         // this.ipv4addr, this.ipv4addr), true, false));
 687         // serDeserTestWithoutBin(new PCEPUnreachedDestinationObject<IPv4Address>(Arrays.asList(this.ipv4addr), true,
 688         // false));
 689         // serDeserTestWithoutBin(new PCEPUnreachedDestinationObject<IPv6Address>(Arrays.asList(this.ipv6addr,
 690         // this.ipv6addr, this.ipv6addr), true, false));
 691         // serDeserTestWithoutBin(new PCEPUnreachedDestinationObject<IPv6Address>(Arrays.asList(this.ipv6addr), true,
 692         // false));
 693         // }
 694 }