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.ArrayList;
  15 import java.util.List;
  16 import java.util.Optional;
  17 import org.junit.Before;
  18 import org.junit.Test;
  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.Meter;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterBandType;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterFlags;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.band.type.band.type.Drop;
  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.DscpRemark;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.band.type.band.type.DscpRemarkBuilder;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.band.type.band.type.Experimenter;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.band.type.band.type.ExperimenterBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.MeterBandHeaders;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.MeterBandHeadersBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.meter.band.headers.MeterBandHeader;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.meter.band.headers.MeterBandHeaderBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.meter.band.headers.meter.band.header.MeterBandTypesBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev150225.ExperimenterIdMeterBand;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MeterModCommand;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MeterModInputBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.meter.band.header.MeterBand;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.meter.band.header.meter.band.MeterBandDropCase;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.meter.band.header.meter.band.MeterBandDscpRemarkCase;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.meter.band.header.meter.band.MeterBandExperimenterCase;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.meter.mod.Bands;
  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.valueOf(10L);
  58         final Uint32  dropRate = Uint32.valueOf(20L);
  59
  60         // / DROP Band
  61         MeterBandTypesBuilder meterBandTypesB = new MeterBandTypesBuilder();
  62
  63         MeterBandType bandFlag = new MeterBandType(true, false, false);
  64         meterBandTypesB.setFlags(bandFlag);// _ofpmbtDrop
  65         DropBuilder drop = new DropBuilder();
  66         drop.setDropBurstSize(burstSize);
  67         drop.setDropRate(dropRate);
  68         Drop drp = drop.build();
  69         MeterBandHeaderBuilder meterBandHeaderBuilder = new MeterBandHeaderBuilder();
  70         meterBandHeaderBuilder.setBandType(drp);
  71         meterBandHeaderBuilder.setMeterBandTypes(meterBandTypesB.build());
  72
  73         final MeterBandHeader meterBH = meterBandHeaderBuilder.build();
  74
  75         // DSCP Mark
  76         final Uint32 dscpRemarkBurstSize = Uint32.valueOf(11L);
  77         final Uint32 dscpRemarkRate = Uint32.valueOf(21L);
  78         final Uint8 dscpPercLevel = Uint8.valueOf(1);
  79
  80         MeterBandTypesBuilder meterBandTypesB1 = new MeterBandTypesBuilder();
  81         MeterBandType bandFlag1 = new MeterBandType(false, true, false);
  82
  83         meterBandTypesB1.setFlags(bandFlag1);
  84         DscpRemarkBuilder dscp = new DscpRemarkBuilder();
  85         dscp.setDscpRemarkBurstSize(dscpRemarkBurstSize);
  86         dscp.setDscpRemarkRate(dscpRemarkRate);
  87         dscp.setPrecLevel(dscpPercLevel);
  88         DscpRemark dscpRemark = dscp.build();
  89
  90         MeterBandHeaderBuilder meterBandHeaderBuilder1 = new MeterBandHeaderBuilder();
  91         meterBandHeaderBuilder1.setBandType(dscpRemark);
  92         meterBandHeaderBuilder1.setMeterBandTypes(meterBandTypesB1.build());
  93
  94         final MeterBandHeader meterBH1 = meterBandHeaderBuilder1.build();
  95
  96         // Experimental
  97         final Uint32 expBurstSize = Uint32.valueOf(12L);
  98         final Uint32 expRate = Uint32.valueOf(22L);
  99         final Uint32 expExperimenter = Uint32.valueOf(23L);
 100
 101         MeterBandTypesBuilder meterBandTypesB2 = new MeterBandTypesBuilder();
 102         MeterBandType bandFlag2 = new MeterBandType(false, false, true);
 103         meterBandTypesB2.setFlags(bandFlag2);
 104
 105         ExperimenterBuilder exp = new ExperimenterBuilder();
 106         exp.setExperimenterBurstSize(expBurstSize);
 107         exp.setExperimenterRate(expRate);
 108         exp.setExperimenter(expExperimenter);
 109         Experimenter experimenter = exp.build();
 110
 111         MeterBandHeaderBuilder meterBandHeaderBuilder2 = new MeterBandHeaderBuilder();
 112         meterBandHeaderBuilder2.setBandType(experimenter);
 113         meterBandHeaderBuilder2.setMeterBandTypes(meterBandTypesB2.build());
 114         MeterBandHeader meterBH2 = meterBandHeaderBuilder2.build();
 115
 116         List<MeterBandHeader> meterBandList = new ArrayList<>();
 117         meterBandList.add(0, meterBH);
 118         meterBandList.add(1, meterBH1);
 119         meterBandList.add(2, meterBH2);
 120
 121         // Constructing List of Bands
 122         MeterBandHeadersBuilder meterBandHeadersBuilder = new MeterBandHeadersBuilder();
 123         meterBandHeadersBuilder.setMeterBandHeader(meterBandList);
 124
 125         MeterBandHeaders meterBandHeaders = meterBandHeadersBuilder.build();
 126
 127         AddMeterInputBuilder addMeterFromSAL = new AddMeterInputBuilder();
 128
 129         addMeterFromSAL.setMeterBandHeaders(meterBandHeaders); // MeterBands
 130
 131         // NodeKey key = new NodeKey(new NodeId("24"));
 132         // InstanceIdentifier<Node> path =
 133         // InstanceIdentifier.builder().node(Nodes.class).node(Node.class,
 134         // key).build();
 135
 136         addMeterFromSAL
 137                 .setMeterId(new org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId(10L));
 138         MeterFlags flagV = new MeterFlags(true, true, true, true);
 139         addMeterFromSAL.setFlags(flagV);
 140
 141         AddMeterInput meterInputCommand = addMeterFromSAL.build();
 142         MeterModInputBuilder outMeterModInput = convert(meterInputCommand, new VersionConvertorData((short) 0X4));
 143
 144         assertEquals(MeterModCommand.OFPMCADD, outMeterModInput.getCommand());
 145         assertTrue(outMeterModInput.getFlags().isOFPMFBURST());
 146         assertEquals(Uint32.valueOf(10L), outMeterModInput.getMeterId().getValue());
 147         // BandInformation starts here:
 148
 149         List<Bands> bands = outMeterModInput.getBands();
 150         for (Bands currentBand : bands) {
 151             MeterBand meterBand = currentBand.getMeterBand();
 152             if (meterBand instanceof MeterBandDropCase) {
 153                 assertEquals(org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731
 154                     .MeterBandType.OFPMBTDROP, ((MeterBandDropCase) meterBand).getMeterBandDrop().getType());
 155                 assertEquals(burstSize, ((MeterBandDropCase) meterBand).getMeterBandDrop().getBurstSize());
 156                 assertEquals(dropRate, ((MeterBandDropCase) meterBand).getMeterBandDrop().getRate());
 157
 158             }
 159             if (meterBand instanceof MeterBandDscpRemarkCase) {
 160                 assertEquals(org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731
 161                     .MeterBandType.OFPMBTDSCPREMARK,
 162                     ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getType());
 163                 assertEquals(dscpRemarkBurstSize,
 164                         ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getBurstSize());
 165                 assertEquals(dscpRemarkRate,
 166                         ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getRate());
 167                 assertEquals(dscpPercLevel,
 168                         ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getPrecLevel());
 169
 170             }
 171             if (meterBand instanceof MeterBandExperimenterCase) {
 172                 assertEquals(org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731
 173                     .MeterBandType.OFPMBTEXPERIMENTER,
 174                     ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getType());
 175                 assertEquals(expBurstSize,
 176                         ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getBurstSize());
 177                 assertEquals(expRate,
 178                         ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getRate());
 179                 ExperimenterIdMeterBand expBand = ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter()
 180                         .augmentation(ExperimenterIdMeterBand.class);
 181                 assertEquals(expExperimenter, expBand.getExperimenter().getValue());
 182             }
 183         }
 184     }
 185
 186     @Test
 187     public void testMeterModCommandConvertorwithNoFlags() {
 188         long burstSize = 10L;
 189         long dropRate = 20L;
 190         // / DROP Band
 191         MeterBandTypesBuilder meterBandTypesB = new MeterBandTypesBuilder();
 192
 193         MeterBandType bandFlag = new MeterBandType(true, false, false);
 194         meterBandTypesB.setFlags(bandFlag);// _ofpmbtDrop
 195         DropBuilder drop = new DropBuilder();
 196         drop.setDropBurstSize(burstSize);
 197         drop.setDropRate(dropRate);
 198         Drop drp = drop.build();
 199
 200         MeterBandHeaderBuilder meterBandHeaderBuilder = new MeterBandHeaderBuilder();
 201         meterBandHeaderBuilder.setBandType(drp);
 202         meterBandHeaderBuilder.setMeterBandTypes(meterBandTypesB.build());
 203
 204         final MeterBandHeader meterBH = meterBandHeaderBuilder.build();
 205
 206         // DSCP Mark
 207         final long dscpRemarkBurstSize = 11L;
 208         final long dscpRemarkRate = 21L;
 209         final short dscpPercLevel = 1;
 210
 211         MeterBandTypesBuilder meterBandTypesB1 = new MeterBandTypesBuilder();
 212         MeterBandType bandFlag1 = new MeterBandType(false, true, false);
 213
 214         meterBandTypesB1.setFlags(bandFlag1);
 215         DscpRemarkBuilder dscp = new DscpRemarkBuilder();
 216
 217         dscp.setDscpRemarkBurstSize(dscpRemarkBurstSize);
 218         dscp.setDscpRemarkRate(dscpRemarkRate);
 219         dscp.setPrecLevel(dscpPercLevel);
 220         DscpRemark dscpRemark = dscp.build();
 221
 222         MeterBandHeaderBuilder meterBandHeaderBuilder1 = new MeterBandHeaderBuilder();
 223         meterBandHeaderBuilder1.setBandType(dscpRemark);
 224         meterBandHeaderBuilder1.setMeterBandTypes(meterBandTypesB1.build());
 225
 226         final MeterBandHeader meterBH1 = meterBandHeaderBuilder1.build();
 227
 228         // Experimental
 229         final long expBurstSize = 12L;
 230         final long expRate = 22L;
 231         final long expExperimenter = 23L;
 232
 233         MeterBandTypesBuilder meterBandTypesB2 = new MeterBandTypesBuilder();
 234         MeterBandType bandFlag2 = new MeterBandType(false, false, true);
 235         meterBandTypesB2.setFlags(bandFlag2);
 236
 237         ExperimenterBuilder exp = new ExperimenterBuilder();
 238
 239         exp.setExperimenterBurstSize(expBurstSize);
 240         exp.setExperimenterRate(expRate);
 241         exp.setExperimenter(expExperimenter);
 242         Experimenter experimenter = exp.build();
 243
 244         MeterBandHeaderBuilder meterBandHeaderBuilder2 = new MeterBandHeaderBuilder();
 245         meterBandHeaderBuilder2.setBandType(experimenter);
 246         meterBandHeaderBuilder2.setMeterBandTypes(meterBandTypesB2.build());
 247         MeterBandHeader meterBH2 = meterBandHeaderBuilder2.build();
 248
 249         List<MeterBandHeader> meterBandList = new ArrayList<>();
 250         meterBandList.add(0, meterBH);
 251         meterBandList.add(1, meterBH1);
 252         meterBandList.add(2, meterBH2);
 253
 254         // Constructing List of Bands
 255         MeterBandHeadersBuilder meterBandHeadersBuilder = new MeterBandHeadersBuilder();
 256         meterBandHeadersBuilder.setMeterBandHeader(meterBandList);
 257
 258         MeterBandHeaders meterBandHeaders = meterBandHeadersBuilder.build();
 259
 260         AddMeterInputBuilder addMeterFromSAL = new AddMeterInputBuilder();
 261
 262         addMeterFromSAL.setMeterBandHeaders(meterBandHeaders); // MeterBands
 263
 264         // NodeKey key = new NodeKey(new NodeId("24"));
 265         // InstanceIdentifier<Node> path =
 266         // InstanceIdentifier.builder().node(Nodes.class).node(Node.class,
 267         // key).build();
 268
 269         addMeterFromSAL
 270                 .setMeterId(new org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId(10L));
 271
 272
 273         AddMeterInput meterInputCommand = addMeterFromSAL.build();
 274         MeterModInputBuilder outMeterModInput = convert(meterInputCommand, new VersionConvertorData((short) 0X4));
 275
 276         assertEquals(MeterModCommand.OFPMCADD, outMeterModInput.getCommand());
 277         assertFalse(outMeterModInput.getFlags().isOFPMFBURST());
 278         assertTrue(outMeterModInput.getFlags().isOFPMFPKTPS());
 279         assertEquals(Uint32.valueOf(10L), outMeterModInput.getMeterId().getValue());
 280         // BandInformation starts here:
 281
 282         List<Bands> bands = outMeterModInput.getBands();
 283         for (Bands currentBand : bands) {
 284             MeterBand meterBand = currentBand.getMeterBand();
 285             if (meterBand instanceof MeterBandDropCase) {
 286                 assertEquals(org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731
 287                     .MeterBandType.OFPMBTDROP, ((MeterBandDropCase) meterBand).getMeterBandDrop().getType());
 288                 assertEquals(burstSize, ((MeterBandDropCase) meterBand).getMeterBandDrop().getBurstSize().toJava());
 289                 assertEquals(dropRate, ((MeterBandDropCase) meterBand).getMeterBandDrop().getRate().toJava());
 290
 291             }
 292             if (meterBand instanceof MeterBandDscpRemarkCase) {
 293                 assertEquals(org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731
 294                     .MeterBandType.OFPMBTDSCPREMARK,
 295                     ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getType());
 296                 assertEquals(dscpRemarkBurstSize,
 297                         ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getBurstSize().toJava());
 298                 assertEquals(dscpRemarkRate,
 299                         ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getRate().toJava());
 300                 assertEquals(dscpPercLevel,
 301                         ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getPrecLevel().toJava());
 302
 303             }
 304             if (meterBand instanceof MeterBandExperimenterCase) {
 305                 assertEquals(org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731
 306                     .MeterBandType.OFPMBTEXPERIMENTER,
 307                      ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getType());
 308                 assertEquals(expBurstSize,
 309                         ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getBurstSize().toJava());
 310                 assertEquals(expRate,
 311                         ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getRate().toJava());
 312                 ExperimenterIdMeterBand expBand = ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter()
 313                         .augmentation(ExperimenterIdMeterBand.class);
 314                 assertEquals(expExperimenter, expBand.getExperimenter().getValue().toJava());
 315             }
 316         }
 317     }
 318
 319     @Test
 320     public void testMeterModCommandConvertorBandDataisNULL() {
 321         AddMeterInputBuilder addMeterFromSAL = new AddMeterInputBuilder();
 322
 323         // NodeKey key = new NodeKey(new NodeId("24"));
 324         // InstanceIdentifier<Node> path =
 325         // InstanceIdentifier.builder().node(Nodes.class).node(Node.class,
 326         // key).build();
 327
 328         addMeterFromSAL
 329                 .setMeterId(new org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId(10L));
 330         MeterFlags flagV = new MeterFlags(true, true, true, true);
 331         addMeterFromSAL.setFlags(flagV);
 332
 333         AddMeterInput meterInputCommand = addMeterFromSAL.build();
 334         MeterModInputBuilder outMeterModInput = convert(meterInputCommand, new VersionConvertorData((short) 0X4));
 335
 336         assertEquals(MeterModCommand.OFPMCADD, outMeterModInput.getCommand());
 337         assertTrue(outMeterModInput.getFlags().isOFPMFBURST());
 338         assertEquals(Uint32.valueOf(10L), outMeterModInput.getMeterId().getValue());
 339     }
 340
 341     @Test
 342     public void testMeterModCommandConvertorNoValidBandData() {
 343
 344         // / DROP Band
 345         MeterBandHeaderBuilder meterBandHeaderBuilder = new MeterBandHeaderBuilder();
 346         MeterBandTypesBuilder meterBandTypesB = new MeterBandTypesBuilder();
 347
 348         MeterBandType bandFlag = new MeterBandType(true, false, false);
 349         meterBandTypesB.setFlags(bandFlag);// _ofpmbtDrop
 350
 351         meterBandHeaderBuilder.setMeterBandTypes(meterBandTypesB.build());
 352
 353         final MeterBandHeader meterBH = meterBandHeaderBuilder.build();
 354
 355         // DSCP Mark
 356         MeterBandTypesBuilder meterBandTypesB1 = new MeterBandTypesBuilder();
 357         MeterBandType bandFlag1 = new MeterBandType(false, true, false);
 358
 359         meterBandTypesB1.setFlags(bandFlag1);
 360         DscpRemarkBuilder dscp = new DscpRemarkBuilder();
 361         dscp.setDscpRemarkBurstSize(11L);
 362         dscp.setDscpRemarkRate(21L);
 363         dscp.setPrecLevel((short) 1);
 364         DscpRemark dscpRemark = dscp.build();
 365
 366         MeterBandHeaderBuilder meterBandHeaderBuilder1 = new MeterBandHeaderBuilder();
 367         meterBandHeaderBuilder1.setBandType(dscpRemark);
 368         meterBandHeaderBuilder1.setMeterBandTypes(meterBandTypesB1.build());
 369
 370         final MeterBandHeader meterBH1 = meterBandHeaderBuilder1.build();
 371
 372         // Experimental
 373
 374         ExperimenterBuilder exp = new ExperimenterBuilder();
 375         exp.setExperimenterBurstSize(12L);
 376         exp.setExperimenterRate(22L);
 377         exp.setExperimenter(23L);
 378         Experimenter experimenter = exp.build();
 379
 380         MeterBandHeaderBuilder meterBandHeaderBuilder2 = new MeterBandHeaderBuilder();
 381         meterBandHeaderBuilder2.setBandType(experimenter);
 382
 383         MeterBandTypesBuilder meterBandTypesB2 = new MeterBandTypesBuilder();
 384         meterBandHeaderBuilder2.setMeterBandTypes(meterBandTypesB2.build());
 385         MeterBandHeader meterBH2 = meterBandHeaderBuilder2.build();
 386
 387         List<MeterBandHeader> meterBandList = new ArrayList<>();
 388         meterBandList.add(0, meterBH);
 389         meterBandList.add(1, meterBH1);
 390         meterBandList.add(2, meterBH2);
 391
 392         // Constructing List of Bands
 393         MeterBandHeadersBuilder meterBandHeadersBuilder = new MeterBandHeadersBuilder();
 394         meterBandHeadersBuilder.setMeterBandHeader(meterBandList);
 395
 396         MeterBandHeaders meterBandHeaders = meterBandHeadersBuilder.build();
 397
 398         AddMeterInputBuilder addMeterFromSAL = new AddMeterInputBuilder();
 399
 400         addMeterFromSAL.setMeterBandHeaders(meterBandHeaders); // MeterBands
 401
 402         // NodeKey key = new NodeKey(new NodeId("24"));
 403         // InstanceIdentifier<Node> path =
 404         // InstanceIdentifier.builder().node(Nodes.class).node(Node.class,
 405         // key).build();
 406
 407         addMeterFromSAL
 408                 .setMeterId(new org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId(10L));
 409         MeterFlags flagV = new MeterFlags(true, true, true, true);
 410         addMeterFromSAL.setFlags(flagV);
 411
 412         AddMeterInput meterInputCommand = addMeterFromSAL.build();
 413         MeterModInputBuilder outMeterModInput = convert(meterInputCommand, new VersionConvertorData((short) 0X4));
 414
 415         assertEquals(MeterModCommand.OFPMCADD, outMeterModInput.getCommand());
 416         assertTrue(outMeterModInput.getFlags().isOFPMFBURST());
 417         assertEquals(Uint32.valueOf(10L), outMeterModInput.getMeterId().getValue());
 418         // BandInformation starts here:
 419
 420         List<Bands> bands = outMeterModInput.getBands();
 421         for (Bands currentBand : bands) {
 422             MeterBand meterBand = currentBand.getMeterBand();
 423             if (meterBand instanceof MeterBandDropCase) {
 424
 425                 assertEquals(org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731
 426                     .MeterBandType.OFPMBTDROP, ((MeterBandDropCase) meterBand).getMeterBandDrop().getType());
 427                 assertEquals(20, ((MeterBandDropCase) meterBand).getMeterBandDrop().getBurstSize());
 428                 assertEquals(10, ((MeterBandDropCase) meterBand).getMeterBandDrop().getRate());
 429
 430             }
 431             if (meterBand instanceof MeterBandDscpRemarkCase) {
 432                 assertEquals(org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731
 433                         .MeterBandType.OFPMBTDSCPREMARK,
 434                         ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getType());
 435                 assertEquals(11,
 436                         ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getBurstSize().toJava());
 437                 assertEquals(21,
 438                         ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getRate().toJava());
 439                 assertEquals((short) 1,
 440                         ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getPrecLevel().toJava());
 441
 442             }
 443             if (meterBand instanceof MeterBandExperimenterCase) {
 444                 assertEquals(org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731
 445                         .MeterBandType.OFPMBTEXPERIMENTER,
 446                         ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getType());
 447                 assertEquals(12,
 448                         ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getBurstSize());
 449                 assertEquals(22,
 450                         ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getRate());
 451                 ExperimenterIdMeterBand expBand = ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter()
 452                         .augmentation(ExperimenterIdMeterBand.class);
 453                 assertEquals(23, expBand.getExperimenter().getValue());
 454             }
 455         }
 456     }
 457
 458     private MeterModInputBuilder convert(final Meter source, final VersionConvertorData data) {
 459         Optional<MeterModInputBuilder> outMeterModInputOptional = convertorManager.convert(source, data);
 460         return outMeterModInputOptional.orElse(MeterConvertor.defaultResult(data.getVersion()));
 461     }
 462 }