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