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 BURST_SIZE = 10L;
  56         long DROP_RATE = 20L;
  57         // / DROP Band
  58         MeterBandHeaderBuilder meterBandHeaderBuilder = new MeterBandHeaderBuilder();
  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(BURST_SIZE);
  65         drop.setDropRate(DROP_RATE);
  66         Drop drp = drop.build();
  67         meterBandHeaderBuilder.setBandType(drp);
  68         meterBandHeaderBuilder.setMeterBandTypes(meterBandTypesB.build());
  69
  70         MeterBandHeader meterBH = meterBandHeaderBuilder.build();
  71
  72         // DSCP Mark
  73         long DSCP_REMARK_BURST_SIZE = 11L;
  74         long DSCP_REMARK_RATE = 21L;
  75         short DSCP_PERC_LEVEL = 1;
  76
  77         MeterBandHeaderBuilder meterBandHeaderBuilder1 = new MeterBandHeaderBuilder();
  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(DSCP_REMARK_BURST_SIZE);
  84         dscp.setDscpRemarkRate(DSCP_REMARK_RATE);
  85         dscp.setPrecLevel(DSCP_PERC_LEVEL);
  86         DscpRemark dscpRemark = dscp.build();
  87         meterBandHeaderBuilder1.setBandType(dscpRemark);
  88         meterBandHeaderBuilder1.setMeterBandTypes(meterBandTypesB1.build());
  89
  90         MeterBandHeader meterBH1 = meterBandHeaderBuilder1.build();
  91
  92         // Experimental
  93         long EXP_BURST_SIZE = 12L;
  94         long EXP_RATE = 22L;
  95         long EXP_EXPERIMENTER = 23L;
  96
  97         MeterBandHeaderBuilder meterBandHeaderBuilder2 = new MeterBandHeaderBuilder();
  98         MeterBandTypesBuilder meterBandTypesB2 = new MeterBandTypesBuilder();
  99         MeterBandType bandFlag2 = new MeterBandType(false, false, true);
 100         meterBandTypesB2.setFlags(bandFlag2);
 101
 102         ExperimenterBuilder exp = new ExperimenterBuilder();
 103         exp.setExperimenterBurstSize(EXP_BURST_SIZE);
 104         exp.setExperimenterRate(EXP_RATE);
 105         exp.setExperimenter(EXP_EXPERIMENTER);
 106         Experimenter experimenter = exp.build();
 107         meterBandHeaderBuilder2.setBandType(experimenter);
 108         meterBandHeaderBuilder2.setMeterBandTypes(meterBandTypesB2.build());
 109         MeterBandHeader meterBH2 = meterBandHeaderBuilder2.build();
 110
 111         List<MeterBandHeader> meterBandList = new ArrayList<MeterBandHeader>();
 112         meterBandList.add(0, meterBH);
 113         meterBandList.add(1, meterBH1);
 114         meterBandList.add(2, meterBH2);
 115
 116         // Constructing List of Bands
 117         MeterBandHeadersBuilder meterBandHeadersBuilder = new MeterBandHeadersBuilder();
 118         meterBandHeadersBuilder.setMeterBandHeader(meterBandList);
 119
 120         MeterBandHeaders meterBandHeaders = meterBandHeadersBuilder.build();
 121
 122         AddMeterInputBuilder addMeterFromSAL = new AddMeterInputBuilder();
 123
 124         addMeterFromSAL.setMeterBandHeaders(meterBandHeaders); // MeterBands
 125         // added to the
 126         // meter command.
 127         Long temp = 10L;
 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(temp, 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
 152                 assertEquals(
 153                         org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MeterBandType.OFPMBTDROP,
 154                         ((MeterBandDropCase) meterBand).getMeterBandDrop().getType());
 155                 assertEquals(BURST_SIZE, (long) ((MeterBandDropCase) meterBand).getMeterBandDrop().getBurstSize());
 156                 assertEquals(DROP_RATE, (long) ((MeterBandDropCase) meterBand).getMeterBandDrop().getRate());
 157
 158             }
 159             if (meterBand instanceof MeterBandDscpRemarkCase) {
 160                 assertEquals(
 161                         org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MeterBandType.OFPMBTDSCPREMARK,
 162                         ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getType());
 163                 assertEquals(DSCP_REMARK_BURST_SIZE, (long) ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getBurstSize());
 164                 assertEquals(DSCP_REMARK_RATE, (long) ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getRate());
 165                 assertEquals(DSCP_PERC_LEVEL, (short) ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getPrecLevel());
 166
 167             }
 168             if (meterBand instanceof MeterBandExperimenterCase) {
 169                 assertEquals(
 170                         org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MeterBandType.OFPMBTEXPERIMENTER,
 171                         ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getType());
 172                 assertEquals(EXP_BURST_SIZE, (long) ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getBurstSize());
 173                 assertEquals(EXP_RATE, (long) ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getRate());
 174                 ExperimenterIdMeterBand expBand = ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter()
 175                         .getAugmentation(ExperimenterIdMeterBand.class);
 176                 assertEquals(EXP_EXPERIMENTER, (long) expBand.getExperimenter().getValue());
 177
 178             }
 179
 180         }
 181
 182     }
 183
 184     @Test
 185     public void testMeterModCommandConvertorwithNoFlags() {
 186         long BURST_SIZE = 10L;
 187         long DROP_RATE = 20L;
 188         // / DROP Band
 189         MeterBandHeaderBuilder meterBandHeaderBuilder = new MeterBandHeaderBuilder();
 190         MeterBandTypesBuilder meterBandTypesB = new MeterBandTypesBuilder();
 191
 192         MeterBandType bandFlag = new MeterBandType(true, false, false);
 193         meterBandTypesB.setFlags(bandFlag);// _ofpmbtDrop
 194         DropBuilder drop = new DropBuilder();
 195         drop.setDropBurstSize(BURST_SIZE);
 196         drop.setDropRate(DROP_RATE);
 197         Drop drp = drop.build();
 198         meterBandHeaderBuilder.setBandType(drp);
 199         meterBandHeaderBuilder.setMeterBandTypes(meterBandTypesB.build());
 200
 201         MeterBandHeader meterBH = meterBandHeaderBuilder.build();
 202
 203         // DSCP Mark
 204         long DSCP_REMARK_BURST_SIZE = 11L;
 205         long DSCP_REMARK_RATE = 21L;
 206         short DSCP_PERC_LEVEL = 1;
 207
 208         MeterBandHeaderBuilder meterBandHeaderBuilder1 = new MeterBandHeaderBuilder();
 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(DSCP_REMARK_BURST_SIZE);
 216         dscp.setDscpRemarkRate(DSCP_REMARK_RATE);
 217         dscp.setPrecLevel(DSCP_PERC_LEVEL);
 218         DscpRemark dscpRemark = dscp.build();
 219         meterBandHeaderBuilder1.setBandType(dscpRemark);
 220         meterBandHeaderBuilder1.setMeterBandTypes(meterBandTypesB1.build());
 221
 222         MeterBandHeader meterBH1 = meterBandHeaderBuilder1.build();
 223
 224         // Experimental
 225         long EXP_BURST_SIZE = 12L;
 226         long EXP_RATE = 22L;
 227         long EXP_EXPERIMENTER = 23L;
 228
 229         MeterBandHeaderBuilder meterBandHeaderBuilder2 = new MeterBandHeaderBuilder();
 230         MeterBandTypesBuilder meterBandTypesB2 = new MeterBandTypesBuilder();
 231         MeterBandType bandFlag2 = new MeterBandType(false, false, true);
 232         meterBandTypesB2.setFlags(bandFlag2);
 233
 234         ExperimenterBuilder exp = new ExperimenterBuilder();
 235
 236         exp.setExperimenterBurstSize(EXP_BURST_SIZE);
 237         exp.setExperimenterRate(EXP_RATE);
 238         exp.setExperimenter(EXP_EXPERIMENTER);
 239         Experimenter experimenter = exp.build();
 240         meterBandHeaderBuilder2.setBandType(experimenter);
 241         meterBandHeaderBuilder2.setMeterBandTypes(meterBandTypesB2.build());
 242         MeterBandHeader meterBH2 = meterBandHeaderBuilder2.build();
 243
 244         List<MeterBandHeader> meterBandList = new ArrayList<MeterBandHeader>();
 245         meterBandList.add(0, meterBH);
 246         meterBandList.add(1, meterBH1);
 247         meterBandList.add(2, meterBH2);
 248
 249         // Constructing List of Bands
 250         MeterBandHeadersBuilder meterBandHeadersBuilder = new MeterBandHeadersBuilder();
 251         meterBandHeadersBuilder.setMeterBandHeader(meterBandList);
 252
 253         MeterBandHeaders meterBandHeaders = meterBandHeadersBuilder.build();
 254
 255         AddMeterInputBuilder addMeterFromSAL = new AddMeterInputBuilder();
 256
 257         addMeterFromSAL.setMeterBandHeaders(meterBandHeaders); // MeterBands
 258         // added to the
 259         // meter command.
 260         Long temp = 10L;
 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(temp, 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
 285                 assertEquals(
 286                         org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MeterBandType.OFPMBTDROP,
 287                         ((MeterBandDropCase) meterBand).getMeterBandDrop().getType());
 288                 assertEquals(BURST_SIZE, (long) ((MeterBandDropCase) meterBand).getMeterBandDrop().getBurstSize());
 289                 assertEquals(DROP_RATE, (long) ((MeterBandDropCase) meterBand).getMeterBandDrop().getRate());
 290
 291             }
 292             if (meterBand instanceof MeterBandDscpRemarkCase) {
 293                 assertEquals(
 294                         org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MeterBandType.OFPMBTDSCPREMARK,
 295                         ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getType());
 296                 assertEquals(DSCP_REMARK_BURST_SIZE, (long) ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getBurstSize());
 297                 assertEquals(DSCP_REMARK_RATE, (long) ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getRate());
 298                 assertEquals(DSCP_PERC_LEVEL, (short) ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getPrecLevel());
 299
 300             }
 301             if (meterBand instanceof MeterBandExperimenterCase) {
 302                 assertEquals(
 303                         org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MeterBandType.OFPMBTEXPERIMENTER,
 304                         ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getType());
 305                 assertEquals(EXP_BURST_SIZE, (long) ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getBurstSize());
 306                 assertEquals(EXP_RATE, (long) ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getRate());
 307                 ExperimenterIdMeterBand expBand = ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter()
 308                         .getAugmentation(ExperimenterIdMeterBand.class);
 309                 assertEquals(EXP_EXPERIMENTER, (long) expBand.getExperimenter().getValue());
 310
 311             }
 312
 313         }
 314
 315     }
 316
 317     @Test
 318     public void testMeterModCommandConvertorBandDataisNULL() {
 319         AddMeterInputBuilder addMeterFromSAL = new AddMeterInputBuilder();
 320
 321         Long temp = 10L;
 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(temp, 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         MeterBandHeader meterBH = meterBandHeaderBuilder.build();
 354
 355         // DSCP Mark
 356         MeterBandHeaderBuilder meterBandHeaderBuilder1 = new MeterBandHeaderBuilder();
 357         MeterBandTypesBuilder meterBandTypesB1 = new MeterBandTypesBuilder();
 358         MeterBandType bandFlag1 = new MeterBandType(false, true, false);
 359
 360         meterBandTypesB1.setFlags(bandFlag1);
 361         DscpRemarkBuilder dscp = new DscpRemarkBuilder();
 362         dscp.setDscpRemarkBurstSize(11L);
 363         dscp.setDscpRemarkRate(21L);
 364         dscp.setPrecLevel((short) 1);
 365         DscpRemark dscpRemark = dscp.build();
 366         meterBandHeaderBuilder1.setBandType(dscpRemark);
 367         meterBandHeaderBuilder1.setMeterBandTypes(meterBandTypesB1.build());
 368
 369         MeterBandHeader meterBH1 = meterBandHeaderBuilder1.build();
 370
 371         // Experimental
 372
 373         MeterBandHeaderBuilder meterBandHeaderBuilder2 = new MeterBandHeaderBuilder();
 374         MeterBandTypesBuilder meterBandTypesB2 = new MeterBandTypesBuilder();
 375
 376
 377         ExperimenterBuilder exp = new ExperimenterBuilder();
 378         exp.setExperimenterBurstSize(12L);
 379         exp.setExperimenterRate(22L);
 380         exp.setExperimenter(23L);
 381         Experimenter experimenter = exp.build();
 382         meterBandHeaderBuilder2.setBandType(experimenter);
 383         meterBandHeaderBuilder2.setMeterBandTypes(meterBandTypesB2.build());
 384         MeterBandHeader meterBH2 = meterBandHeaderBuilder2.build();
 385
 386         List<MeterBandHeader> meterBandList = new ArrayList<MeterBandHeader>();
 387         meterBandList.add(0, meterBH);
 388         meterBandList.add(1, meterBH1);
 389         meterBandList.add(2, meterBH2);
 390
 391         // Constructing List of Bands
 392         MeterBandHeadersBuilder meterBandHeadersBuilder = new MeterBandHeadersBuilder();
 393         meterBandHeadersBuilder.setMeterBandHeader(meterBandList);
 394
 395         MeterBandHeaders meterBandHeaders = meterBandHeadersBuilder.build();
 396
 397         AddMeterInputBuilder addMeterFromSAL = new AddMeterInputBuilder();
 398
 399         addMeterFromSAL.setMeterBandHeaders(meterBandHeaders); // MeterBands
 400         // added to the
 401         // meter command.
 402         Long temp = 10L;
 403
 404         // NodeKey key = new NodeKey(new NodeId("24"));
 405         // InstanceIdentifier<Node> path =
 406         // InstanceIdentifier.builder().node(Nodes.class).node(Node.class,
 407         // key).build();
 408
 409         addMeterFromSAL
 410                 .setMeterId(new org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId(10L));
 411         MeterFlags flagV = new MeterFlags(true, true, true, true);
 412         addMeterFromSAL.setFlags(flagV);
 413
 414         AddMeterInput meterInputCommand = addMeterFromSAL.build();
 415         MeterModInputBuilder outMeterModInput = convert(meterInputCommand, new VersionConvertorData((short) 0X4));
 416
 417         assertEquals(MeterModCommand.OFPMCADD, outMeterModInput.getCommand());
 418         assertTrue(outMeterModInput.getFlags().isOFPMFBURST());
 419         assertEquals(temp, outMeterModInput.getMeterId().getValue());
 420         // BandInformation starts here:
 421
 422         List<Bands> bands = outMeterModInput.getBands();
 423         for (Bands currentBand : bands) {
 424             MeterBand meterBand = currentBand.getMeterBand();
 425             if (meterBand instanceof MeterBandDropCase) {
 426
 427                 assertEquals(
 428                         org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MeterBandType.OFPMBTDROP,
 429                         ((MeterBandDropCase) meterBand).getMeterBandDrop().getType());
 430                 assertEquals((long) 20, (long) ((MeterBandDropCase) meterBand).getMeterBandDrop().getBurstSize());
 431                 assertEquals((long) 10, (long) ((MeterBandDropCase) meterBand).getMeterBandDrop().getRate());
 432
 433             }
 434             if (meterBand instanceof MeterBandDscpRemarkCase) {
 435                 assertEquals(
 436                         org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MeterBandType.OFPMBTDSCPREMARK,
 437                         ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getType());
 438                 assertEquals((long) 11, (long) ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getBurstSize());
 439                 assertEquals((long) 21, (long) ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getRate());
 440                 assertEquals((short) 1, (short) ((MeterBandDscpRemarkCase) meterBand).getMeterBandDscpRemark().getPrecLevel());
 441
 442             }
 443             if (meterBand instanceof MeterBandExperimenterCase) {
 444                 assertEquals(
 445                         org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MeterBandType.OFPMBTEXPERIMENTER,
 446                         ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getType());
 447                 assertEquals((long) 12, (long) ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getBurstSize());
 448                 assertEquals((long) 22, (long) ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter().getRate());
 449                 ExperimenterIdMeterBand expBand = ((MeterBandExperimenterCase) meterBand).getMeterBandExperimenter()
 450                         .getAugmentation(ExperimenterIdMeterBand.class);
 451                 assertEquals((long) 23, (long) expBand.getExperimenter().getValue());
 452
 453             }
 454
 455         }
 456
 457     }
 458
 459     private MeterModInputBuilder convert(Meter source, VersionConvertorData data) {
 460         Optional<MeterModInputBuilder> outMeterModInputOptional = convertorManager.convert(source, data);
 461         return outMeterModInputOptional.orElse(MeterConvertor.defaultResult(data.getVersion()));
 462     }
 463 }