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