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