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