pcep/impl/src/test/java/org/opendaylight/protocol/pcep/impl/CompositeTest.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.assertEquals;
  11 import static org.junit.Assert.assertNull;
  12
  13 import java.io.IOException;
  14 import java.util.ArrayList;
  15 import java.util.List;
  16
  17 import org.junit.Before;
  18 import org.junit.Test;
  19 import org.opendaylight.protocol.concepts.ASNumber;
  20 import org.opendaylight.protocol.concepts.Bandwidth;
  21 import org.opendaylight.protocol.concepts.IPv4Address;
  22 import org.opendaylight.protocol.concepts.TEMetric;
  23 import org.opendaylight.protocol.pcep.PCEPErrors;
  24 import org.opendaylight.protocol.pcep.PCEPObject;
  25 import org.opendaylight.protocol.pcep.PCEPTlv;
  26 import org.opendaylight.protocol.pcep.object.CompositeErrorObject;
  27 import org.opendaylight.protocol.pcep.object.CompositeNotifyObject;
  28 import org.opendaylight.protocol.pcep.object.CompositePathObject;
  29 import org.opendaylight.protocol.pcep.object.CompositeRequestObject;
  30 import org.opendaylight.protocol.pcep.object.CompositeResponseObject;
  31 import org.opendaylight.protocol.pcep.object.CompositeRptPathObject;
  32 import org.opendaylight.protocol.pcep.object.CompositeStateReportObject;
  33 import org.opendaylight.protocol.pcep.object.CompositeUpdPathObject;
  34 import org.opendaylight.protocol.pcep.object.CompositeUpdateRequestObject;
  35 import org.opendaylight.protocol.pcep.object.PCEPClassTypeObject;
  36 import org.opendaylight.protocol.pcep.object.PCEPEndPointsObject;
  37 import org.opendaylight.protocol.pcep.object.PCEPErrorObject;
  38 import org.opendaylight.protocol.pcep.object.PCEPExistingPathBandwidthObject;
  39 import org.opendaylight.protocol.pcep.object.PCEPExplicitRouteObject;
  40 import org.opendaylight.protocol.pcep.object.PCEPIncludeRouteObject;
  41 import org.opendaylight.protocol.pcep.object.PCEPLoadBalancingObject;
  42 import org.opendaylight.protocol.pcep.object.PCEPLspObject;
  43 import org.opendaylight.protocol.pcep.object.PCEPLspaObject;
  44 import org.opendaylight.protocol.pcep.object.PCEPMetricObject;
  45 import org.opendaylight.protocol.pcep.object.PCEPNoPathObject;
  46 import org.opendaylight.protocol.pcep.object.PCEPNotificationObject;
  47 import org.opendaylight.protocol.pcep.object.PCEPOpenObject;
  48 import org.opendaylight.protocol.pcep.object.PCEPReportedRouteObject;
  49 import org.opendaylight.protocol.pcep.object.PCEPRequestParameterObject;
  50 import org.opendaylight.protocol.pcep.object.PCEPRequestedPathBandwidthObject;
  51 import org.opendaylight.protocol.pcep.subobject.EROAsNumberSubobject;
  52 import org.opendaylight.protocol.pcep.subobject.ExplicitRouteSubobject;
  53 import org.opendaylight.protocol.pcep.subobject.RROAsNumberSubobject;
  54 import org.opendaylight.protocol.pcep.subobject.ReportedRouteSubobject;
  55 import org.opendaylight.protocol.pcep.tlv.LSPCleanupTlv;
  56 import org.opendaylight.protocol.pcep.tlv.PCEStatefulCapabilityTlv;
  57
  58 public class CompositeTest {
  59
  60         public PCEPExplicitRouteObject ero;
  61         public PCEPClassTypeObject ct;
  62         public PCEPLspaObject lspa;
  63         public List<PCEPMetricObject> metrics = new ArrayList<PCEPMetricObject>();
  64         public PCEPIncludeRouteObject iro = new PCEPIncludeRouteObject(new ArrayList<ExplicitRouteSubobject>() {
  65                 private static final long serialVersionUID = 1L;
  66
  67                 {
  68                         this.add(new EROAsNumberSubobject(new ASNumber(0L), true));
  69                 }
  70         }, false, false);
  71         public PCEPRequestParameterObject requestParameter;
  72         public PCEPNoPathObject noPath;
  73         public PCEPRequestedPathBandwidthObject bandwidth;
  74
  75         public List<PCEPRequestParameterObject> requestParameters = new ArrayList<PCEPRequestParameterObject>();
  76         public PCEPErrorObject error;
  77         public List<PCEPErrorObject> errors = new ArrayList<PCEPErrorObject>();
  78
  79         public PCEPNotificationObject notification;
  80         public List<PCEPNotificationObject> notifications = new ArrayList<PCEPNotificationObject>();
  81
  82         private PCEPReportedRouteObject reportedRoute;
  83         private PCEPExistingPathBandwidthObject rroBandwidth;
  84         private PCEPIncludeRouteObject includeRoute;
  85         private PCEPLoadBalancingObject loadBalancing;
  86         private PCEPEndPointsObject<?> endPoints;
  87
  88         private PCEPLspObject lsp;
  89         private final List<CompositePathObject> compositePaths = new ArrayList<CompositePathObject>();
  90         private final List<CompositeRptPathObject> compositeRptPaths = new ArrayList<CompositeRptPathObject>();
  91         private final List<CompositeUpdPathObject> compositeUpdPaths = new ArrayList<CompositeUpdPathObject>();
  92         public PCEPReportedRouteObject rro = new PCEPReportedRouteObject(new ArrayList<ReportedRouteSubobject>() {
  93                 private static final long serialVersionUID = 1L;
  94
  95                 {
  96                         this.add(new RROAsNumberSubobject(new ASNumber(0L)));
  97                 }
  98         }, false);
  99
 100         @Before
 101         public void setUp() {
 102                 this.ero = new PCEPExplicitRouteObject(new ArrayList<ExplicitRouteSubobject>() {
 103                         private static final long serialVersionUID = 1L;
 104
 105                         {
 106                                 this.add(new EROAsNumberSubobject(new ASNumber(0L), true));
 107                         }
 108                 }, false);
 109                 this.ct = new PCEPClassTypeObject((short) 5);
 110                 this.lspa = new PCEPLspaObject(0, 0, 0, (short) 0, (short) 0, false, false, false, false);
 111                 this.metrics.add(new PCEPMetricObject(false, false, new TEMetric(1000), false, false));
 112                 this.metrics.add(new PCEPMetricObject(false, false, new TEMetric(1000), false, false));
 113
 114                 this.requestParameter = new PCEPRequestParameterObject(false, false, false, false, false, false, false, false, (short) 0, 0, false, false);
 115                 this.noPath = new PCEPNoPathObject((short) 2, false, false);
 116                 this.bandwidth = new PCEPRequestedPathBandwidthObject(new Bandwidth(0), false, false);
 117
 118                 this.requestParameters.add(this.requestParameter);
 119                 this.requestParameters.add(this.requestParameter);
 120
 121                 this.error = new PCEPErrorObject(PCEPErrors.BANDWIDTH_MISSING);
 122
 123                 this.errors.add(this.error);
 124                 this.errors.add(this.error);
 125                 this.errors.add(this.error);
 126
 127                 this.notification = new PCEPNotificationObject((short) 1, (short) 1);
 128
 129                 this.notifications.add(this.notification);
 130                 this.notifications.add(this.notification);
 131
 132                 final List<ExplicitRouteSubobject> eroSubobjects = new ArrayList<ExplicitRouteSubobject>();
 133                 eroSubobjects.add(new EROAsNumberSubobject(new ASNumber(0x0L), false));
 134                 eroSubobjects.add(new EROAsNumberSubobject(new ASNumber(0x0L), false));
 135                 eroSubobjects.add(new EROAsNumberSubobject(new ASNumber(0x0L), false));
 136
 137                 final List<ReportedRouteSubobject> rroSubobjects = new ArrayList<ReportedRouteSubobject>();
 138                 rroSubobjects.add(new RROAsNumberSubobject(new ASNumber(0x0L)));
 139                 rroSubobjects.add(new RROAsNumberSubobject(new ASNumber(0x0L)));
 140                 rroSubobjects.add(new RROAsNumberSubobject(new ASNumber(0x0L)));
 141
 142                 this.reportedRoute = new PCEPReportedRouteObject(rroSubobjects, true);
 143                 this.rroBandwidth = new PCEPExistingPathBandwidthObject(new Bandwidth(Float.intBitsToFloat(0xFF)), true, false);
 144                 this.includeRoute = new PCEPIncludeRouteObject(eroSubobjects, true, false);
 145                 this.loadBalancing = new PCEPLoadBalancingObject(0x0, new Bandwidth(Float.intBitsToFloat(0x0)), false);
 146                 final byte[] ipbytes = { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF };
 147                 this.endPoints = new PCEPEndPointsObject<IPv4Address>(new IPv4Address(ipbytes), new IPv4Address(ipbytes));
 148
 149                 this.lsp = new PCEPLspObject(0, false, false, true, true, null);
 150                 this.compositePaths.add(new CompositePathObject(new PCEPExplicitRouteObject(eroSubobjects, true), this.lspa, this.bandwidth, this.metrics,
 151                                 this.includeRoute));
 152                 this.compositePaths.add(new CompositePathObject(new PCEPExplicitRouteObject(eroSubobjects, true)));
 153
 154                 this.compositeUpdPaths.add(new CompositeUpdPathObject(new PCEPExplicitRouteObject(eroSubobjects, true), this.lspa, this.bandwidth, this.metrics));
 155                 this.compositeUpdPaths.add(new CompositeUpdPathObject(new PCEPExplicitRouteObject(eroSubobjects, true)));
 156
 157         }
 158
 159         @Test
 160         public void testCompositePathObject() {
 161                 final List<PCEPObject> objects = new ArrayList<PCEPObject>();
 162                 objects.add(this.ero);
 163                 objects.add(this.lspa);
 164                 objects.add(this.metrics.get(0));
 165                 objects.add(this.metrics.get(1));
 166                 objects.add(this.iro);
 167                 objects.add(new PCEPMetricObject(false, false, new TEMetric(1000), false, false));
 168                 final CompositePathObject path = CompositePathObject.getCompositeFromList(objects);
 169                 assertEquals(path.getExcludedRoute(), this.ero);
 170                 assertEquals(path.getLspa(), this.lspa);
 171                 assertNull(path.getBandwidth());
 172                 assertEquals(path.getMetrics().get(0), this.metrics.get(0));
 173                 assertEquals(path.getMetrics().get(1), this.metrics.get(1));
 174                 assertEquals(path.getIncludeRoute(), this.iro);
 175         }
 176
 177         @Test
 178         public void testCompositeRptPathObject() {
 179                 final List<PCEPObject> objects = new ArrayList<PCEPObject>();
 180                 objects.add(this.ero);
 181                 objects.add(this.lspa);
 182                 objects.add(this.rro);
 183                 objects.add(this.metrics.get(0));
 184                 objects.add(this.metrics.get(1));
 185                 objects.add(new PCEPMetricObject(false, false, new TEMetric(1000), false, false));
 186                 final CompositeRptPathObject path = CompositeRptPathObject.getCompositeFromList(objects);
 187                 assertEquals(path.getExcludedRoute(), this.ero);
 188                 assertEquals(path.getLspa(), this.lspa);
 189                 assertNull(path.getBandwidth());
 190                 assertEquals(path.getMetrics().get(0), this.metrics.get(0));
 191                 assertEquals(path.getMetrics().get(1), this.metrics.get(1));
 192                 assertEquals(path.getReportedRoute(), this.rro);
 193         }
 194
 195         @Test
 196         public void testCompositeResponseObject() {
 197                 final List<PCEPObject> objects = new ArrayList<PCEPObject>();
 198                 objects.add(this.requestParameter);
 199                 objects.add(this.noPath);
 200                 objects.add(this.bandwidth);
 201                 objects.add(this.metrics.get(0));
 202                 objects.add(this.metrics.get(1));
 203                 objects.add(this.iro);
 204                 // add one path
 205                 objects.add(this.ero);
 206                 objects.add(this.lspa);
 207                 objects.add(this.metrics.get(0));
 208                 objects.add(this.metrics.get(1));
 209                 objects.add(this.iro);
 210                 // add another path
 211                 objects.add(this.ero);
 212                 objects.add(this.lspa);
 213                 objects.add(this.metrics.get(0));
 214                 objects.add(new PCEPMetricObject(false, false, new TEMetric(1000), false, false));
 215                 objects.add(this.iro);
 216                 //
 217                 objects.add(this.requestParameter);
 218                 final List<CompositeResponseObject> list = new ArrayList<CompositeResponseObject>();
 219                 while (!objects.isEmpty()) {
 220                         list.add(CompositeResponseObject.getCompositeFromList(objects));
 221                 }
 222                 assertEquals(2, list.size());
 223                 final CompositeResponseObject response = list.get(0);
 224
 225                 assertEquals(response.getRequestParameter(), this.requestParameter);
 226                 assertEquals(response.getNoPath(), this.noPath);
 227                 assertNull(response.getLspa());
 228                 assertEquals(response.getBandwidth(), this.bandwidth);
 229                 assertEquals(response.getMetrics().get(0), this.metrics.get(0));
 230                 assertEquals(response.getMetrics().get(1), this.metrics.get(1));
 231                 assertEquals(response.getIncludeRoute(), this.iro);
 232                 // check path
 233                 CompositePathObject path = response.getPaths().get(0);
 234                 assertEquals(path.getExcludedRoute(), this.ero);
 235                 assertEquals(path.getLspa(), this.lspa);
 236                 assertNull(path.getBandwidth());
 237                 assertEquals(path.getMetrics().get(0), this.metrics.get(0));
 238                 assertEquals(path.getMetrics().get(1), this.metrics.get(1));
 239                 assertEquals(path.getIncludeRoute(), this.iro);
 240                 // check path
 241                 path = response.getPaths().get(1);
 242                 assertEquals(path.getExcludedRoute(), this.ero);
 243                 assertEquals(path.getLspa(), this.lspa);
 244                 assertNull(path.getBandwidth());
 245                 assertEquals(path.getMetrics().get(0), this.metrics.get(0));
 246                 assertEquals(path.getMetrics().get(1), new PCEPMetricObject(false, false, new TEMetric(1000), false, false));
 247                 assertEquals(path.getIncludeRoute(), this.iro);
 248         }
 249
 250         @Test
 251         public void testCompositeErrorObject() {
 252                 final List<PCEPObject> objects = new ArrayList<PCEPObject>();
 253                 CompositeErrorObject compositeErrors;
 254
 255                 objects.addAll(this.requestParameters);
 256                 objects.addAll(this.errors);
 257                 compositeErrors = new CompositeErrorObject(this.requestParameters.subList(0, this.requestParameters.size()), this.errors.subList(0, this.errors.size()));
 258                 assertEquals(compositeErrors, CompositeErrorObject.getCompositeFromList(objects));
 259
 260                 objects.clear();
 261                 objects.addAll(this.errors);
 262                 compositeErrors = new CompositeErrorObject(null, this.errors.subList(0, this.errors.size()));
 263                 assertEquals(compositeErrors, CompositeErrorObject.getCompositeFromList(objects));
 264
 265         }
 266
 267         @Test
 268         public void testCompositeNotifyObject() {
 269                 final List<PCEPObject> objects = new ArrayList<PCEPObject>();
 270                 CompositeNotifyObject compositeNotifications;
 271
 272                 objects.addAll(this.requestParameters);
 273                 objects.addAll(this.notifications);
 274                 compositeNotifications = new CompositeNotifyObject(this.requestParameters.subList(0, this.requestParameters.size()), this.notifications.subList(0,
 275                                 this.notifications.size()));
 276                 assertEquals(compositeNotifications, CompositeNotifyObject.getCompositeFromList(objects));
 277
 278                 objects.clear();
 279                 // first
 280                 objects.addAll(this.requestParameters);
 281                 objects.addAll(this.notifications);
 282                 // second
 283                 objects.addAll(this.requestParameters);
 284                 objects.addAll(this.notifications);
 285                 while (!objects.isEmpty()) {
 286                         assertEquals(compositeNotifications, CompositeNotifyObject.getCompositeFromList(objects));
 287                 }
 288
 289                 objects.clear();
 290                 objects.addAll(this.notifications);
 291                 compositeNotifications = new CompositeNotifyObject(null, this.notifications.subList(0, this.notifications.size()));
 292                 assertEquals(compositeNotifications, CompositeNotifyObject.getCompositeFromList(objects));
 293
 294         }
 295
 296         @Test
 297         public void testCompositeRequestObject() {
 298                 final List<PCEPObject> objects = new ArrayList<PCEPObject>();
 299                 CompositeRequestObject compositeRequest;
 300
 301                 objects.add(this.requestParameter);
 302                 objects.add(this.endPoints);
 303                 objects.add(this.ct);
 304                 objects.add(this.lsp);
 305                 objects.add(this.lspa);
 306                 objects.add(this.bandwidth);
 307                 objects.addAll(this.metrics);
 308                 objects.add(this.reportedRoute);
 309                 objects.add(this.rroBandwidth);
 310                 objects.add(this.includeRoute);
 311                 objects.add(this.loadBalancing);
 312
 313                 compositeRequest = new CompositeRequestObject(this.requestParameter, this.endPoints, this.ct, this.lsp, this.lspa, this.bandwidth,
 314                                 this.metrics.subList(0, this.metrics.size()), this.reportedRoute, this.rroBandwidth, this.includeRoute, this.loadBalancing);
 315                 assertEquals(compositeRequest, CompositeRequestObject.getCompositeFromList(objects));
 316
 317                 objects.clear();
 318                 // first
 319                 objects.add(this.requestParameter);
 320                 objects.add(this.endPoints);
 321                 objects.add(this.ct);
 322                 objects.add(this.lsp);
 323                 objects.add(this.lspa);
 324                 objects.add(this.bandwidth);
 325                 objects.addAll(this.metrics);
 326                 objects.add(this.reportedRoute);
 327                 objects.add(this.rroBandwidth);
 328                 objects.add(this.includeRoute);
 329                 objects.add(this.loadBalancing);
 330                 // second
 331                 objects.add(this.requestParameter);
 332                 objects.add(this.endPoints);
 333                 objects.add(this.ct);
 334                 objects.add(this.lsp);
 335                 objects.add(this.lspa);
 336                 objects.add(this.bandwidth);
 337                 objects.addAll(this.metrics);
 338                 objects.add(this.reportedRoute);
 339                 objects.add(this.rroBandwidth);
 340                 objects.add(this.includeRoute);
 341                 objects.add(this.loadBalancing);
 342                 while (!objects.isEmpty()) {
 343                         assertEquals(compositeRequest, CompositeRequestObject.getCompositeFromList(objects));
 344                 }
 345
 346                 objects.clear();
 347                 objects.add(this.requestParameter);
 348                 objects.add(this.endPoints);
 349                 compositeRequest = new CompositeRequestObject(this.requestParameter, this.endPoints);
 350                 assertEquals(compositeRequest, CompositeRequestObject.getCompositeFromList(objects));
 351
 352         }
 353
 354         @Test
 355         public void testCompositeStateReportObject() {
 356                 final List<PCEPObject> objects = new ArrayList<PCEPObject>();
 357                 CompositeStateReportObject compositeStateReport;
 358
 359                 objects.add(this.lsp);
 360                 for (final CompositeRptPathObject compositeRptPath : this.compositeRptPaths) {
 361                         objects.addAll(compositeRptPath.getCompositeAsList());
 362                 }
 363
 364                 compositeStateReport = new CompositeStateReportObject(this.lsp, this.compositeRptPaths);
 365                 assertEquals(compositeStateReport, CompositeStateReportObject.getCompositeFromList(objects));
 366
 367                 objects.clear();
 368                 // first
 369                 objects.add(this.lsp);
 370                 for (final CompositeRptPathObject compositeRptPath : this.compositeRptPaths) {
 371                         objects.addAll(compositeRptPath.getCompositeAsList());
 372                 }
 373                 // second
 374                 objects.add(this.lsp);
 375                 for (final CompositeRptPathObject compositeRptPath : this.compositeRptPaths) {
 376                         objects.addAll(compositeRptPath.getCompositeAsList());
 377                 }
 378                 while (!objects.isEmpty()) {
 379                         assertEquals(compositeStateReport, CompositeStateReportObject.getCompositeFromList(objects));
 380                 }
 381
 382                 objects.clear();
 383                 objects.add(this.lsp);
 384                 for (final CompositeRptPathObject compositeRptPath : this.compositeRptPaths) {
 385                         objects.addAll(compositeRptPath.getCompositeAsList());
 386                 }
 387                 compositeStateReport = new CompositeStateReportObject(this.lsp, this.compositeRptPaths);
 388                 assertEquals(compositeStateReport, CompositeStateReportObject.getCompositeFromList(objects));
 389
 390         }
 391
 392         @Test
 393         public void testCompositeUpdateRequestObject() {
 394                 final List<PCEPObject> objects = new ArrayList<PCEPObject>();
 395                 CompositeUpdateRequestObject compositeStateReport;
 396
 397                 objects.add(this.lsp);
 398                 for (final CompositeUpdPathObject compositePath : this.compositeUpdPaths) {
 399                         objects.addAll(compositePath.getCompositeAsList());
 400                 }
 401
 402                 compositeStateReport = new CompositeUpdateRequestObject(this.lsp, this.compositeUpdPaths);
 403                 assertEquals(compositeStateReport, CompositeUpdateRequestObject.getCompositeFromList(objects));
 404
 405                 objects.clear();
 406                 // first
 407                 objects.add(this.lsp);
 408                 for (final CompositeUpdPathObject compositePath : this.compositeUpdPaths) {
 409                         objects.addAll(compositePath.getCompositeAsList());
 410                 }
 411                 // second
 412                 objects.add(this.lsp);
 413                 for (final CompositeUpdPathObject compositePath : this.compositeUpdPaths) {
 414                         objects.addAll(compositePath.getCompositeAsList());
 415                 }
 416                 while (!objects.isEmpty()) {
 417                         assertEquals(compositeStateReport, CompositeUpdateRequestObject.getCompositeFromList(objects));
 418                 }
 419
 420                 objects.clear();
 421                 objects.add(this.lsp);
 422                 for (final CompositeUpdPathObject compositePath : this.compositeUpdPaths) {
 423                         objects.addAll(compositePath.getCompositeAsList());
 424                 }
 425                 compositeStateReport = new CompositeUpdateRequestObject(this.lsp, this.compositeUpdPaths);
 426                 assertEquals(compositeStateReport, CompositeUpdateRequestObject.getCompositeFromList(objects));
 427
 428         }
 429
 430         @Test
 431         public void testSessionProposalFactory() throws IOException {
 432                 final PCEPSessionProposalFactoryImpl spf = new PCEPSessionProposalFactoryImpl(10, 2, true, false, true, true, 5);
 433                 final List<PCEPTlv> tlvs = new ArrayList<PCEPTlv>();
 434                 tlvs.add(new PCEStatefulCapabilityTlv(true, false, true));
 435                 tlvs.add(new LSPCleanupTlv(5));
 436                 assertEquals(new PCEPOpenObject(2, 10, 0, tlvs), spf.getSessionProposal(null, 0));
 437         }
 438 }