openflowplugin/src/test/java/org/opendaylight/openflowplugin/openflow/md/core/sal/convertor/MeterConvertorTest.java

   1 /*
   2  * Copyright (c) 2014 Ericsson India Global Services Pvt Ltd. 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.openflowplugin.openflow.md.core.sal.convertor;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertFalse;
  12 import static org.junit.Assert.assertTrue;
  13
  14 import java.util.List;
  15 import java.util.Optional;
  16 import org.junit.Before;
  17 import org.junit.Test;
  18 import org.opendaylight.openflowplugin.api.OFConstants;
  19 import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.data.VersionConvertorData;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.AddMeterInput;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.AddMeterInputBuilder;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.BandId;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.Meter;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterBandType;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterFlags;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.band.type.band.type.DropBuilder;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.band.type.band.type.DscpRemarkBuilder;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.band.type.band.type.ExperimenterBuilder;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.MeterBandHeaders;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.MeterBandHeadersBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.meter.band.headers.MeterBandHeader;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.meter.band.headers.MeterBandHeaderBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.meter.band.headers.MeterBandHeaderKey;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.meter.band.headers.meter.band.header.MeterBandTypesBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev150225.ExperimenterIdMeterBand;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MeterModCommand;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MeterModInputBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.meter.band.header.MeterBand;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.meter.band.header.meter.band.MeterBandDropCase;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.meter.band.header.meter.band.MeterBandDscpRemarkCase;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.meter.band.header.meter.band.MeterBandExperimenterCase;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.meter.mod.Bands;
  43 import org.opendaylight.yangtools.yang.binding.util.BindingMap;
  44 import org.opendaylight.yangtools.yang.common.Uint32;
  45 import org.opendaylight.yangtools.yang.common.Uint8;
  46
  47 public class MeterConvertorTest {
  48     private ConvertorManager convertorManager;
  49
  50     @Before
  51     public void setUp() {
  52         convertorManager = ConvertorManagerFactory.createDefaultManager();
  53     }
  54
  55     @Test
  56     public void testMeterModCommandConvertorwithAllParameters() {
  57         final Uint32 burstSize = Uint32.TEN;
  58         final Uint32  dropRate = Uint32.valueOf(20);
  59
  60         // / DROP Band
  61         MeterBandHeaderBuilder meterBandHeaderBuilder = new MeterBandHeaderBuilder()
  62             .setBandType(new DropBuilder()
  63                 .setDropBurstSize(burstSize)
  64                 .setDropRate(dropRate)
  65                 .build())
  66             // _ofpmbtDrop
  67             .setMeterBandTypes(new MeterBandTypesBuilder().setFlags(new MeterBandType(true, false, false)).build())
  68             .withKey(new MeterBandHeaderKey(new BandId(Uint32.ZERO)));
  69
  70         // DSCP Mark
  71         final Uint32 dscpRemarkBurstSize = Uint32.valueOf(11L);
  72         final Uint32 dscpRemarkRate = Uint32.valueOf(21L);
  73         final Uint8 dscpPercLevel = Uint8.ONE;
  74
  75         MeterBandHeaderBuilder meterBandHeaderBuilder1 = new MeterBandHeaderBuilder()
  76             .setBandType(new DscpRemarkBuilder()
  77                 .setDscpRemarkBurstSize(dscpRemarkBurstSize)
  78                 .setDscpRemarkRate(dscpRemarkRate)
  79                 .setPrecLevel(dscpPercLevel)
  80                 .build())
  81             .setMeterBandTypes(new MeterBandTypesBuilder()
  82                 .setFlags(new MeterBandType(false, true, false))
  83                 .build())
  84             .withKey(new MeterBandHeaderKey(new BandId(Uint32.ONE)));
  85
  86
  87         // Experimental
  88         final Uint32 expBurstSize = Uint32.valueOf(12L);
  89         final Uint32 expRate = Uint32.valueOf(22L);
  90         final Uint32 expExperimenter = Uint32.valueOf(23L);
  91
  92         MeterBandHeaderBuilder meterBandHeaderBuilder2 = new MeterBandHeaderBuilder()
  93             .setBandType(new ExperimenterBuilder()
  94                 .setExperimenterBurstSize(expBurstSize)
  95                 .setExperimenterRate(expRate)
  96                 .setExperimenter(expExperimenter)
  97                 .build())
  98             .setMeterBandTypes(new MeterBandTypesBuilder().setFlags(new MeterBandType(false, false, true)).build())
  99             .withKey(new MeterBandHeaderKey(new BandId(Uint32.TWO)));
 100
 101         MeterBandHeaders meterBandHeaders = new MeterBandHeadersBuilder()
 102             .setMeterBandHeader(BindingMap.ordered(
 103                 meterBandHeaderBuilder.build(), meterBandHeaderBuilder1.build(), meterBandHeaderBuilder2.build()))
 104             .build();
 105
 106         AddMeterInputBuilder addMeterFromSAL = new AddMeterInputBuilder();
 107
 108         addMeterFromSAL.setMeterBandHeaders(meterBandHeaders); // MeterBands
 109
 110         // NodeKey key = new NodeKey(new NodeId("24"));
 111         // InstanceIdentifier<Node> path =
 112         // InstanceIdentifier.builder().node(Nodes.class).node(Node.class,
 113         // key).build();
 114
 115         addMeterFromSAL.setMeterId(
 116             new org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId(Uint32.TEN));
 117         MeterFlags flagV = new MeterFlags(true, true, true, true);
 118         addMeterFromSAL.setFlags(flagV);
 119
 120         AddMeterInput meterInputCommand = addMeterFromSAL.build();
 121         MeterModInputBuilder outMeterModInput = convert(meterInputCommand,
 122             new VersionConvertorData(OFConstants.OFP_VERSION_1_3));
 123
 124         assertEquals(MeterModCommand.OFPMCADD, outMeterModInput.getCommand());
 125         assertTrue(outMeterModInput.getFlags().getOFPMFBURST());
 126         assertEquals(Uint32.valueOf(10L), outMeterModInput.getMeterId().getValue());
 127         // BandInformation starts here:
 128
 129         List<Bands> bands = outMeterModInput.getBands();
 130         for (Bands currentBand : bands) {
 131             MeterBand meterBand = currentBand.getMeterBand();
 132             if (meterBand instanceof MeterBandDropCase) {
 133                 assertEquals(org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731
 134                     .MeterBandType.OFPMBTDROP, ((MeterBandDropCase) meterBand).getMeterBandDrop().getType());
 135                 assertEquals(burstSize, ((MeterBandDropCase) meterBand).getMeterBandDrop().getBurstSize());
 136                 assertEquals(dropRate, ((MeterBandDropCase) meterBand).getMeterBandDrop().getRate());
 137
 138             }
 139             if (meterBand instanceof MeterBandDscpRemarkCase) {
 140                 assertEquals(org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731
 141                     .MeterBandType.OFPMBTDSCPREMARK,
 142                     ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getType());
 143                 assertEquals(dscpRemarkBurstSize,
 144                         ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getBurstSize());
 145                 assertEquals(dscpRemarkRate,
 146                         ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getRate());
 147                 assertEquals(dscpPercLevel,
 148                         ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getPrecLevel());
 149
 150             }
 151             if (meterBand instanceof MeterBandExperimenterCase) {
 152                 assertEquals(org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731
 153                     .MeterBandType.OFPMBTEXPERIMENTER,
 154                     ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getType());
 155                 assertEquals(expBurstSize,
 156                         ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getBurstSize());
 157                 assertEquals(expRate,
 158                         ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getRate());
 159                 ExperimenterIdMeterBand expBand = ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter()
 160                         .augmentation(ExperimenterIdMeterBand.class);
 161                 assertEquals(expExperimenter, expBand.getExperimenter().getValue());
 162             }
 163         }
 164     }
 165
 166     @Test
 167     public void testMeterModCommandConvertorwithNoFlags() {
 168         final Uint32 burstSize = Uint32.TEN;
 169         final Uint32 dropRate = Uint32.valueOf(20);
 170         // / DROP Band
 171
 172         final MeterBandHeader meterBH = new MeterBandHeaderBuilder()
 173             .setBandType(new DropBuilder().setDropBurstSize(burstSize).setDropRate(dropRate).build())
 174             // _ofpmbtDrop
 175             .setMeterBandTypes(new MeterBandTypesBuilder().setFlags(new MeterBandType(true, false, false)).build())
 176             .withKey(new MeterBandHeaderKey(new BandId(Uint32.ZERO)))
 177             .build();
 178
 179         // DSCP Mark
 180         final Uint32 dscpRemarkBurstSize = Uint32.valueOf(11);
 181         final Uint32 dscpRemarkRate = Uint32.valueOf(21);
 182         final Uint8 dscpPercLevel = Uint8.ONE;
 183
 184         final MeterBandHeader meterBH1 = new MeterBandHeaderBuilder()
 185             .setBandType(new DscpRemarkBuilder()
 186                 .setDscpRemarkBurstSize(dscpRemarkBurstSize)
 187                 .setDscpRemarkRate(dscpRemarkRate)
 188                 .setPrecLevel(dscpPercLevel)
 189                 .build())
 190             .setMeterBandTypes(new MeterBandTypesBuilder().setFlags(new MeterBandType(false, true, false)).build())
 191             .withKey(new MeterBandHeaderKey(new BandId(Uint32.ONE)))
 192             .build();
 193
 194         // Experimental
 195         final Uint32 expBurstSize = Uint32.valueOf(12);
 196         final Uint32 expRate = Uint32.valueOf(22);
 197         final Uint32 expExperimenter = Uint32.valueOf(23);
 198
 199         MeterBandHeader meterBH2 = new MeterBandHeaderBuilder()
 200             .setBandType(new ExperimenterBuilder()
 201                 .setExperimenterBurstSize(expBurstSize)
 202                 .setExperimenterRate(expRate)
 203                 .setExperimenter(expExperimenter)
 204                 .build())
 205             .setMeterBandTypes(new MeterBandTypesBuilder().setFlags(new MeterBandType(false, false, true)).build())
 206             .withKey(new MeterBandHeaderKey(new BandId(Uint32.TWO)))
 207             .build();
 208
 209         // Constructing List of Bands
 210         MeterBandHeaders meterBandHeaders = new MeterBandHeadersBuilder()
 211             .setMeterBandHeader(BindingMap.ordered(meterBH, meterBH1, meterBH2))
 212             .build();
 213
 214         AddMeterInputBuilder addMeterFromSAL = new AddMeterInputBuilder();
 215
 216         addMeterFromSAL.setMeterBandHeaders(meterBandHeaders); // MeterBands
 217
 218         // NodeKey key = new NodeKey(new NodeId("24"));
 219         // InstanceIdentifier<Node> path =
 220         // InstanceIdentifier.builder().node(Nodes.class).node(Node.class,
 221         // key).build();
 222
 223         addMeterFromSAL.setMeterId(
 224             new org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId(Uint32.TEN));
 225
 226         AddMeterInput meterInputCommand = addMeterFromSAL.build();
 227         MeterModInputBuilder outMeterModInput = convert(meterInputCommand,
 228             new VersionConvertorData(OFConstants.OFP_VERSION_1_3));
 229
 230         assertEquals(MeterModCommand.OFPMCADD, outMeterModInput.getCommand());
 231         assertFalse(outMeterModInput.getFlags().getOFPMFBURST());
 232         assertTrue(outMeterModInput.getFlags().getOFPMFPKTPS());
 233         assertEquals(Uint32.TEN, outMeterModInput.getMeterId().getValue());
 234         // BandInformation starts here:
 235
 236         List<Bands> bands = outMeterModInput.getBands();
 237         for (Bands currentBand : bands) {
 238             MeterBand meterBand = currentBand.getMeterBand();
 239             if (meterBand instanceof MeterBandDropCase) {
 240                 assertEquals(org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731
 241                     .MeterBandType.OFPMBTDROP, ((MeterBandDropCase) meterBand).getMeterBandDrop().getType());
 242                 assertEquals(burstSize, ((MeterBandDropCase) meterBand).getMeterBandDrop().getBurstSize());
 243                 assertEquals(dropRate, ((MeterBandDropCase) meterBand).getMeterBandDrop().getRate());
 244
 245             }
 246             if (meterBand instanceof MeterBandDscpRemarkCase) {
 247                 assertEquals(org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731
 248                     .MeterBandType.OFPMBTDSCPREMARK,
 249                     ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getType());
 250                 assertEquals(dscpRemarkBurstSize,
 251                         ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getBurstSize());
 252                 assertEquals(dscpRemarkRate,
 253                         ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getRate());
 254                 assertEquals(dscpPercLevel,
 255                         ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getPrecLevel());
 256
 257             }
 258             if (meterBand instanceof MeterBandExperimenterCase) {
 259                 assertEquals(org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731
 260                     .MeterBandType.OFPMBTEXPERIMENTER,
 261                      ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getType());
 262                 assertEquals(expBurstSize,
 263                         ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getBurstSize());
 264                 assertEquals(expRate,
 265                         ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getRate());
 266                 ExperimenterIdMeterBand expBand = ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter()
 267                         .augmentation(ExperimenterIdMeterBand.class);
 268                 assertEquals(expExperimenter, expBand.getExperimenter().getValue());
 269             }
 270         }
 271     }
 272
 273     @Test
 274     public void testMeterModCommandConvertorBandDataisNULL() {
 275         // NodeKey key = new NodeKey(new NodeId("24"));
 276         // InstanceIdentifier<Node> path =
 277         // InstanceIdentifier.builder().node(Nodes.class).node(Node.class,
 278         // key).build();
 279
 280         MeterModInputBuilder outMeterModInput = convert(new AddMeterInputBuilder()
 281             .setMeterId(new org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId(Uint32.TEN))
 282             .setFlags(new MeterFlags(true, true, true, true))
 283             .build(), new VersionConvertorData(OFConstants.OFP_VERSION_1_3));
 284
 285         assertEquals(MeterModCommand.OFPMCADD, outMeterModInput.getCommand());
 286         assertTrue(outMeterModInput.getFlags().getOFPMFBURST());
 287         assertEquals(Uint32.valueOf(10L), outMeterModInput.getMeterId().getValue());
 288     }
 289
 290     @Test
 291     public void testMeterModCommandConvertorNoValidBandData() {
 292         // / DROP Band
 293         final MeterBandHeader meterBH = new MeterBandHeaderBuilder()
 294             // _ofpmbtDrop
 295             .setMeterBandTypes(new MeterBandTypesBuilder().setFlags(new MeterBandType(true, false, false)).build())
 296             .withKey(new MeterBandHeaderKey(new BandId(Uint32.ZERO)))
 297             .build();
 298
 299         // DSCP Mark
 300         final MeterBandHeader meterBH1 = new MeterBandHeaderBuilder()
 301             .setBandType(new DscpRemarkBuilder()
 302                 .setDscpRemarkBurstSize(Uint32.valueOf(11))
 303                 .setDscpRemarkRate(Uint32.valueOf(21))
 304                 .setPrecLevel(Uint8.ONE)
 305                 .build())
 306             .setMeterBandTypes(new MeterBandTypesBuilder().setFlags(new MeterBandType(false, true, false)).build())
 307             .withKey(new MeterBandHeaderKey(new BandId(Uint32.ONE)))
 308             .build();
 309
 310         // Experimental
 311         MeterBandHeader meterBH2 = new MeterBandHeaderBuilder()
 312             .setBandType(new ExperimenterBuilder()
 313                 .setExperimenterBurstSize(Uint32.valueOf(12))
 314                 .setExperimenterRate(Uint32.valueOf(22))
 315                 .setExperimenter(Uint32.valueOf(23))
 316                 .build())
 317             .setMeterBandTypes(new MeterBandTypesBuilder().build())
 318             .withKey(new MeterBandHeaderKey(new BandId(Uint32.TWO)))
 319             .build();
 320
 321         // Constructing List of Bands
 322         MeterBandHeaders meterBandHeaders = new MeterBandHeadersBuilder()
 323             .setMeterBandHeader(BindingMap.ordered(meterBH, meterBH1, meterBH2))
 324             .build();
 325
 326         AddMeterInputBuilder addMeterFromSAL = new AddMeterInputBuilder();
 327
 328         addMeterFromSAL.setMeterBandHeaders(meterBandHeaders); // MeterBands
 329
 330         // NodeKey key = new NodeKey(new NodeId("24"));
 331         // InstanceIdentifier<Node> path =
 332         // InstanceIdentifier.builder().node(Nodes.class).node(Node.class,
 333         // key).build();
 334
 335         addMeterFromSAL.setMeterId(
 336             new org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId(Uint32.TEN));
 337         MeterFlags flagV = new MeterFlags(true, true, true, true);
 338         addMeterFromSAL.setFlags(flagV);
 339
 340         AddMeterInput meterInputCommand = addMeterFromSAL.build();
 341         MeterModInputBuilder outMeterModInput = convert(meterInputCommand,
 342             new VersionConvertorData(OFConstants.OFP_VERSION_1_3));
 343
 344         assertEquals(MeterModCommand.OFPMCADD, outMeterModInput.getCommand());
 345         assertTrue(outMeterModInput.getFlags().getOFPMFBURST());
 346         assertEquals(Uint32.valueOf(10L), outMeterModInput.getMeterId().getValue());
 347         // BandInformation starts here:
 348
 349         List<Bands> bands = outMeterModInput.getBands();
 350         for (Bands currentBand : bands) {
 351             MeterBand meterBand = currentBand.getMeterBand();
 352             if (meterBand instanceof MeterBandDropCase) {
 353
 354                 assertEquals(org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731
 355                     .MeterBandType.OFPMBTDROP, ((MeterBandDropCase) meterBand).getMeterBandDrop().getType());
 356                 assertEquals(20, ((MeterBandDropCase) meterBand).getMeterBandDrop().getBurstSize());
 357                 assertEquals(10, ((MeterBandDropCase) meterBand).getMeterBandDrop().getRate());
 358
 359             }
 360             if (meterBand instanceof MeterBandDscpRemarkCase) {
 361                 assertEquals(org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731
 362                         .MeterBandType.OFPMBTDSCPREMARK,
 363                         ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getType());
 364                 assertEquals(11,
 365                         ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getBurstSize().toJava());
 366                 assertEquals(21,
 367                         ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getRate().toJava());
 368                 assertEquals((short) 1,
 369                         ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getPrecLevel().toJava());
 370
 371             }
 372             if (meterBand instanceof MeterBandExperimenterCase) {
 373                 assertEquals(org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731
 374                         .MeterBandType.OFPMBTEXPERIMENTER,
 375                         ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getType());
 376                 assertEquals(12,
 377                         ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getBurstSize());
 378                 assertEquals(22,
 379                         ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getRate());
 380                 ExperimenterIdMeterBand expBand = ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter()
 381                         .augmentation(ExperimenterIdMeterBand.class);
 382                 assertEquals(23, expBand.getExperimenter().getValue());
 383             }
 384         }
 385     }
 386
 387     private MeterModInputBuilder convert(final Meter source, final VersionConvertorData data) {
 388         Optional<MeterModInputBuilder> outMeterModInputOptional = convertorManager.convert(source, data);
 389         return outMeterModInputOptional.orElse(MeterConvertor.defaultResult(data.getVersion()));
 390     }
 391 }