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