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