openflowplugin/src/test/java/org/opendaylight/openflowplugin/openflow/md/core/sal/convertor/MeterConvertorTest.java

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