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