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

   1 /**
   2  * Copyright (c) 2014 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor;
   9
  10 import com.google.common.collect.ImmutableList;
  11 import java.math.BigInteger;
  12 import java.util.ArrayList;
  13 import java.util.List;
  14 import org.junit.Assert;
  15 import org.junit.Test;
  16 import org.opendaylight.openflowplugin.openflow.md.util.OpenflowPortsUtil;
  17 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.CopyTtlInCaseBuilder;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.GroupActionCase;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.GroupActionCaseBuilder;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.OutputActionCaseBuilder;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetMplsTtlActionCaseBuilder;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.copy.ttl.in._case.CopyTtlIn;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.copy.ttl.in._case.CopyTtlInBuilder;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.group.action._case.GroupAction;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.group.action._case.GroupActionBuilder;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.output.action._case.OutputActionBuilder;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.mpls.ttl.action._case.SetMplsTtlAction;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.mpls.ttl.action._case.SetMplsTtlActionBuilder;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.AddGroupInput;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.AddGroupInputBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.BucketId;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupTypes;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.Buckets;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.BucketsBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.Bucket;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.BucketBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev150203.actions.grouping.Action;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.GroupModCommand;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.GroupType;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GroupModInputBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.buckets.grouping.BucketsList;
  45
  46 public class GroupConvertorTest {
  47
  48     /**
  49      * test of {@link GroupConvertor#toGroupModInput(org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.Group, short, java.math.BigInteger)}
  50      */
  51     @Test
  52     public void testGroupModConvertorwithallParameters() {
  53
  54         final AddGroupInputBuilder addGroupBuilder = new AddGroupInputBuilder();
  55
  56         addGroupBuilder.setGroupId(new GroupId(10L));
  57
  58         addGroupBuilder.setGroupType(GroupTypes.GroupAll);
  59         final List<Bucket> bucketList = new ArrayList<Bucket>();
  60         final List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
  61         final List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList1 = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
  62
  63         int actionOrder = 0;
  64
  65         // Action1
  66         final GroupActionBuilder groupActionBuilder = new GroupActionBuilder();
  67         groupActionBuilder.setGroup("005");
  68         final GroupAction groupIdaction = groupActionBuilder.build();
  69         final ActionBuilder actionsB = new ActionBuilder();
  70         actionsB.setOrder(actionOrder++).setAction(new GroupActionCaseBuilder().setGroupAction(groupIdaction).build());
  71
  72         // Action2:
  73         final GroupActionBuilder groupActionBuilder1 = new GroupActionBuilder();
  74         groupActionBuilder1.setGroup("006");
  75         final GroupAction groupIdaction1 = groupActionBuilder.build();
  76         final ActionBuilder actionsB1 = new ActionBuilder();
  77         actionsB1.setOrder(actionOrder++).setAction(new GroupActionCaseBuilder().setGroupAction(groupIdaction1).build());
  78
  79         actionsList.add(actionsB.build());
  80         actionsList.add(actionsB1.build());
  81
  82
  83         final BucketsBuilder bucketsB = new BucketsBuilder();
  84
  85         final BucketBuilder bucketB = new BucketBuilder();
  86         bucketB.setWeight(10);
  87         bucketB.setWatchPort(20L);
  88         bucketB.setWatchGroup(22L);
  89
  90         bucketB.setAction(actionsList);
  91         final Bucket bucket = bucketB.build();
  92
  93         bucketList.add(bucket); // List of bucket
  94
  95         final BucketBuilder bucketB1 = new BucketBuilder();
  96         bucketB1.setWeight(50);
  97         bucketB1.setWatchPort(60L);
  98         bucketB1.setWatchGroup(70L);
  99
 100         // Action1
 101         final CopyTtlInBuilder copyTtlB = new CopyTtlInBuilder();
 102         final CopyTtlIn copyTtl = copyTtlB.build();
 103         final ActionBuilder actionsB2 = new ActionBuilder();
 104         actionsB2.setOrder(actionOrder++).setAction(new CopyTtlInCaseBuilder().setCopyTtlIn(copyTtl).build());
 105
 106         // Action2:
 107         final SetMplsTtlActionBuilder setMplsTtlActionBuilder = new SetMplsTtlActionBuilder();
 108         setMplsTtlActionBuilder.setMplsTtl((short) 0X1);
 109         final SetMplsTtlAction setMAction = setMplsTtlActionBuilder.build();
 110         final ActionBuilder actionsB3 = new ActionBuilder();
 111
 112         actionsB3.setOrder(actionOrder++).setAction(new SetMplsTtlActionCaseBuilder().setSetMplsTtlAction(setMAction).build());
 113
 114
 115         actionsList1.add(actionsB2.build());
 116         actionsList1.add(actionsB3.build());
 117
 118         bucketB1.setAction(actionsList);
 119
 120         final Bucket bucket1 = bucketB1.build(); // second bucket
 121
 122         bucketList.add(bucket1);
 123
 124         bucketsB.setBucket(bucketList);// List of bucket added to the Buckets
 125         final Buckets buckets = bucketsB.build();
 126
 127         addGroupBuilder.setBuckets(buckets);
 128
 129         final GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(addGroupBuilder.build(), (short) 0X4, BigInteger.valueOf(1));
 130
 131         Assert.assertEquals(GroupModCommand.OFPGCADD, outAddGroupInput.getCommand());
 132         Assert.assertEquals(GroupType.OFPGTALL, outAddGroupInput.getType());
 133
 134         Assert.assertEquals(10L, (long) outAddGroupInput.getGroupId().getValue());
 135         Assert.assertEquals(10, (int) outAddGroupInput.getBucketsList().get(0).getWeight());
 136         Assert.assertEquals(20L, (long) outAddGroupInput.getBucketsList().get(0).getWatchPort().getValue());
 137         Assert.assertEquals((Long) 22L, outAddGroupInput.getBucketsList().get(0).getWatchGroup());
 138
 139         final List<Action> outActionList = outAddGroupInput.getBucketsList().get(0).getAction();
 140         for (int outItem = 0; outItem < outActionList.size(); outItem++) {
 141             final Action action = outActionList
 142                     .get(outItem);
 143             if (action.getActionChoice() instanceof GroupActionCase) {
 144                 Assert.assertEquals((Long) 5L, ((GroupActionCase) action.getActionChoice()).getGroupAction().getGroupId());
 145
 146             }
 147             // TODO:setMplsTTL :OF layer doesnt have get();
 148         }
 149
 150         Assert.assertEquals((Integer) 50, outAddGroupInput.getBucketsList().get(1).getWeight());
 151         Assert.assertEquals((long) 60, (long) outAddGroupInput.getBucketsList().get(1).getWatchPort().getValue());
 152         Assert.assertEquals((Long) 70L, outAddGroupInput.getBucketsList().get(1).getWatchGroup());
 153         final List<Action> outActionList1 = outAddGroupInput.getBucketsList().get(1).getAction();
 154         for (int outItem = 0; outItem < outActionList1.size(); outItem++) {
 155             final Action action = outActionList1
 156                     .get(outItem);
 157             if (action.getActionChoice() instanceof GroupActionCase) {
 158
 159                 Assert.assertEquals((Long) 6L, ((GroupActionCase) action.getActionChoice()).getGroupAction().getGroupId());
 160
 161
 162             }
 163             // TODO:setMplsTTL :OF layer doesnt have get();
 164         }
 165
 166     }
 167
 168     /**
 169      * test of {@link GroupConvertor#toGroupModInput(org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.Group, short, java.math.BigInteger)}
 170      */
 171     @Test
 172     public void testGroupModConvertorNoBucket() {
 173         final AddGroupInputBuilder addGroupBuilder = new AddGroupInputBuilder();
 174
 175         addGroupBuilder.setGroupId(new GroupId(10L));
 176
 177         addGroupBuilder.setGroupType(GroupTypes.GroupAll);
 178
 179         final GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(addGroupBuilder.build(), (short) 0X4, BigInteger.valueOf(1));
 180
 181         Assert.assertEquals(GroupModCommand.OFPGCADD, outAddGroupInput.getCommand());
 182         Assert.assertEquals(GroupType.OFPGTALL, outAddGroupInput.getType());
 183     }
 184
 185     /**
 186      * test of {@link GroupConvertor#toGroupModInput(org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.Group, short, java.math.BigInteger)}
 187      */
 188     @Test
 189     public void testGroupModConvertorBucketwithNOWieghtValuesForGroupTypeFastFailure() {
 190
 191         int actionOrder = 0;
 192
 193         final AddGroupInputBuilder addGroupBuilder = new AddGroupInputBuilder();
 194
 195         addGroupBuilder.setGroupId(new GroupId(10L));
 196
 197         addGroupBuilder.setGroupType(GroupTypes.GroupFf);
 198         final List<Bucket> bucketList = new ArrayList<Bucket>();
 199         final List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
 200         final List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList1 = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
 201
 202         // Action1: 005
 203         actionsList.add(assembleActionBuilder("005", actionOrder++).build());
 204         // Action2: 006
 205         actionsList.add(assembleActionBuilder("006", actionOrder++).build());
 206         // .. and mr.Bond is not coming today
 207
 208         final BucketsBuilder bucketsB = new BucketsBuilder();
 209
 210         final BucketBuilder bucketB = new BucketBuilder();
 211
 212         bucketB.setAction(actionsList);
 213         final Bucket bucket = bucketB.build();
 214
 215         bucketList.add(bucket); // List of bucket
 216
 217
 218         final BucketBuilder bucketB1 = new BucketBuilder();
 219
 220         // Action1
 221         actionsList1.add(assembleCopyTtlInBuilder(actionOrder++).build());
 222         // Action2:
 223         actionsList1.add(assembleSetMplsTtlActionBuilder(actionOrder++).build());
 224
 225         bucketB1.setAction(actionsList1);
 226
 227         final Bucket bucket1 = bucketB1.build(); // second bucket
 228
 229         bucketList.add(bucket1);
 230
 231         bucketsB.setBucket(bucketList);// List of bucket added to the Buckets
 232         final Buckets buckets = bucketsB.build();
 233
 234         addGroupBuilder.setBuckets(buckets);
 235
 236         final GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(addGroupBuilder.build(), (short) 0X4, BigInteger.valueOf(1));
 237
 238         Assert.assertEquals(GroupModCommand.OFPGCADD, outAddGroupInput.getCommand());
 239         Assert.assertEquals(GroupType.OFPGTFF, outAddGroupInput.getType());
 240
 241         Assert.assertEquals(10L, outAddGroupInput.getGroupId().getValue().longValue());
 242
 243         final List<Action> outActionList = outAddGroupInput.getBucketsList().get(0).getAction();
 244         for (int outItem = 0; outItem < outActionList.size(); outItem++) {
 245             final Action action = outActionList
 246                     .get(outItem);
 247             if (action.getActionChoice() instanceof GroupActionCase) {
 248                 Assert.assertEquals((Long) 5L, ((GroupActionCase) action.getActionChoice()).getGroupAction().getGroupId());
 249             }
 250         }
 251
 252         final List<Action> outActionList1 = outAddGroupInput.getBucketsList().get(1).getAction();
 253         for (int outItem = 0; outItem < outActionList1.size(); outItem++) {
 254             final Action action = outActionList1
 255                     .get(outItem);
 256             if (action.getActionChoice() instanceof GroupActionCase) {
 257                 Assert.assertEquals((Long) 6L, ((GroupActionCase) action.getActionChoice()).getGroupAction().getGroupId());
 258             }
 259         }
 260     }
 261
 262     /**
 263      * test of {@link GroupConvertor#toGroupModInput(org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.Group, short, java.math.BigInteger)}
 264      */
 265     @Test
 266     public void testGroupModConvertSortedBuckets() {
 267
 268         final int actionOrder = 0;
 269
 270         final ArrayList<Bucket> bucket = new ArrayList<Bucket>();
 271
 272         bucket.add(new BucketBuilder()
 273                         .setBucketId(new BucketId((long) 4))
 274                         .setWatchPort((long)2)
 275                         .setWatchGroup((long) 1)
 276                         .setAction(ImmutableList.of(new ActionBuilder()
 277                         .setOrder(0)
 278                         .setAction(new OutputActionCaseBuilder()
 279                                         .setOutputAction(new OutputActionBuilder()
 280                                                                 .setOutputNodeConnector(new Uri("openflow:1:2"))
 281                                                                 .build())
 282                                         .build())
 283                         .build()))
 284         .build());
 285
 286         bucket.add(new BucketBuilder()
 287                         .setBucketId(new BucketId((long) 3))
 288                         .setWatchPort((long)6)
 289                         .setWatchGroup((long) 1)
 290                         .setAction(ImmutableList.of(new ActionBuilder()
 291                         .setOrder(0)
 292                         .setAction(new OutputActionCaseBuilder()
 293                                         .setOutputAction(new OutputActionBuilder()
 294                                                                 .setOutputNodeConnector(new Uri("openflow:1:6"))
 295                                                                 .build())
 296                                         .build())
 297                         .build()))
 298                 .build());
 299
 300         bucket.add(new BucketBuilder()
 301                         .setBucketId(new BucketId((long) 2))
 302                         .setWatchPort((long)5)
 303                         .setWatchGroup((long) 1)
 304                         .setAction(ImmutableList.of(new ActionBuilder()
 305                         .setOrder(0)
 306                         .setAction(new OutputActionCaseBuilder()
 307                                         .setOutputAction(new OutputActionBuilder()
 308                                                                 .setOutputNodeConnector(new Uri("openflow:1:5"))
 309                                                                 .build())
 310                                         .build())
 311                         .build()))
 312                 .build());
 313
 314         bucket.add(new BucketBuilder()
 315                     .setBucketId(new BucketId((long) 1))
 316                     .setWatchPort((long)4)
 317                     .setWatchGroup((long) 1)
 318                     .setAction(ImmutableList.of(new ActionBuilder()
 319                     .setOrder(0)
 320                     .setAction(new OutputActionCaseBuilder()
 321                                     .setOutputAction(new OutputActionBuilder()
 322                                                             .setOutputNodeConnector(new Uri("openflow:1:4"))
 323                                                             .build())
 324                                     .build())
 325                     .build()))
 326             .build());
 327
 328         bucket.add(new BucketBuilder()
 329                     .setBucketId(new BucketId((long) 0))
 330                     .setWatchPort((long)3)
 331                     .setWatchGroup((long) 1)
 332                     .setAction(ImmutableList.of(new ActionBuilder()
 333                     .setOrder(0)
 334                     .setAction(new OutputActionCaseBuilder()
 335                                     .setOutputAction(new OutputActionBuilder()
 336                                                             .setOutputNodeConnector(new Uri("openflow:1:3"))
 337                                                             .build())
 338                                     .build())
 339                     .build()))
 340                     .build());
 341
 342
 343         final AddGroupInput input = new AddGroupInputBuilder()
 344                                     .setGroupId(new GroupId((long) 1))
 345                                     .setGroupName("Foo")
 346                                     .setGroupType(GroupTypes.GroupFf)
 347                                     .setBuckets(new BucketsBuilder()
 348                                                        .setBucket(bucket)
 349                                                        .build())
 350                                     .build();
 351
 352         OpenflowPortsUtil.init();
 353
 354         final GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(input, (short) 0X4, BigInteger.valueOf(1));
 355
 356         final List<BucketsList> bucketList = outAddGroupInput.getBucketsList();
 357         Assert.assertEquals( Long.valueOf(1), bucketList.get(0).getWatchGroup());
 358         Assert.assertEquals( Long.valueOf(3), bucketList.get(0).getWatchPort().getValue());
 359
 360         Assert.assertEquals( Long.valueOf(1), bucketList.get(1).getWatchGroup());
 361         Assert.assertEquals( Long.valueOf(4), bucketList.get(1).getWatchPort().getValue());
 362
 363         Assert.assertEquals( Long.valueOf(1), bucketList.get(2).getWatchGroup());
 364         Assert.assertEquals( Long.valueOf(5), bucketList.get(2).getWatchPort().getValue());
 365
 366         Assert.assertEquals( Long.valueOf(1), bucketList.get(3).getWatchGroup());
 367         Assert.assertEquals( Long.valueOf(6), bucketList.get(3).getWatchPort().getValue());
 368
 369         Assert.assertEquals( Long.valueOf(1), bucketList.get(4).getWatchGroup());
 370         Assert.assertEquals( Long.valueOf(2), bucketList.get(4).getWatchPort().getValue());
 371
 372
 373     }
 374
 375     /**
 376      * @return
 377      */
 378     private static ActionBuilder assembleSetMplsTtlActionBuilder(final int actionOrder) {
 379         final SetMplsTtlActionBuilder setMplsTtlActionBuilder = new SetMplsTtlActionBuilder();
 380         setMplsTtlActionBuilder.setMplsTtl((short) 0X1);
 381         final SetMplsTtlActionCaseBuilder setMplsTtlActionCaseBuilder = new SetMplsTtlActionCaseBuilder();
 382         setMplsTtlActionCaseBuilder.setSetMplsTtlAction(setMplsTtlActionBuilder.build());
 383         final ActionBuilder actionsB3 = new ActionBuilder();
 384         actionsB3.setOrder(actionOrder).setAction(setMplsTtlActionCaseBuilder.build());
 385         return actionsB3;
 386     }
 387
 388     /**
 389      * @return
 390      */
 391     private static ActionBuilder assembleCopyTtlInBuilder(final int actionOrder) {
 392         final CopyTtlInBuilder copyTtlB = new CopyTtlInBuilder();
 393         final CopyTtlInCaseBuilder copyTtlInCaseBuilder = new CopyTtlInCaseBuilder();
 394         copyTtlInCaseBuilder.setCopyTtlIn(copyTtlB.build());
 395         final ActionBuilder actionsB2 = new ActionBuilder();
 396         actionsB2.setOrder(actionOrder).setAction(copyTtlInCaseBuilder.build());
 397         return actionsB2;
 398     }
 399
 400     /**
 401      * @param groupName name of group
 402      * @return
 403      */
 404     private static ActionBuilder assembleActionBuilder(final String groupName, final int actionOrder) {
 405         final GroupActionBuilder groupActionBuilder = new GroupActionBuilder();
 406         groupActionBuilder.setGroup(groupName);
 407         final GroupActionCaseBuilder groupActionCaseBuilder = new GroupActionCaseBuilder();
 408         groupActionCaseBuilder.setGroupAction(groupActionBuilder.build());
 409         final ActionBuilder actionsBld = new ActionBuilder();
 410         actionsBld.setOrder(actionOrder).setAction(groupActionCaseBuilder.build());
 411         return actionsBld;
 412     }
 413
 414     /**
 415      * test of {@link GroupConvertor#toGroupModInput(org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.Group, short, java.math.BigInteger)} )}
 416      */
 417     @Test
 418     public void testGroupModConvertorBucketwithNOWieghtValuesForGroupTypeAll() {
 419
 420         int actionOrder = 0;
 421
 422         final AddGroupInputBuilder addGroupBuilder = new AddGroupInputBuilder();
 423
 424         addGroupBuilder.setGroupId(new GroupId(10L));
 425
 426         addGroupBuilder.setGroupType(GroupTypes.GroupAll);
 427         final List<Bucket> bucketList = new ArrayList<Bucket>();
 428         final List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
 429         final List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList1 = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
 430
 431         // Action1
 432         actionsList.add(assembleActionBuilder("005", actionOrder++).build());
 433         // Action2:
 434         actionsList.add(assembleActionBuilder("006", actionOrder++).build());
 435
 436         final BucketsBuilder bucketsB = new BucketsBuilder();
 437
 438         final BucketBuilder bucketB = new BucketBuilder();
 439
 440         bucketB.setAction(actionsList);
 441         final Bucket bucket = bucketB.build();
 442
 443         bucketList.add(bucket); // List of bucket
 444
 445         final BucketBuilder bucketB1 = new BucketBuilder();
 446
 447         // Action1
 448         actionsList1.add(assembleCopyTtlInBuilder(actionOrder++).build());
 449         // Action2:
 450         actionsList1.add(assembleSetMplsTtlActionBuilder(actionOrder++).build());
 451
 452         bucketB1.setAction(actionsList);
 453
 454         final Bucket bucket1 = bucketB1.build(); // second bucket
 455
 456         bucketList.add(bucket1);
 457
 458         bucketsB.setBucket(bucketList);// List of bucket added to the Buckets
 459         final Buckets buckets = bucketsB.build();
 460
 461         addGroupBuilder.setBuckets(buckets);
 462
 463         final GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(addGroupBuilder.build(), (short) 0X4, BigInteger.valueOf(1));
 464
 465         Assert.assertEquals(GroupModCommand.OFPGCADD, outAddGroupInput.getCommand());
 466         Assert.assertEquals(GroupType.OFPGTALL, outAddGroupInput.getType());
 467
 468         Assert.assertEquals(10L, outAddGroupInput.getGroupId().getValue().longValue());
 469
 470         final List<Action> outActionList = outAddGroupInput.getBucketsList().get(0).getAction();
 471         for (int outItem = 0; outItem < outActionList.size(); outItem++) {
 472             final Action action = outActionList
 473                     .get(outItem);
 474             if (action.getActionChoice() instanceof GroupActionCase) {
 475                 Assert.assertEquals((Long) 5L, ((GroupActionCase) action.getActionChoice()).getGroupAction().getGroupId());
 476
 477             }
 478
 479         }
 480
 481         final List<Action> outActionList1 = outAddGroupInput.getBucketsList().get(1).getAction();
 482         for (int outItem = 0; outItem < outActionList1.size(); outItem++) {
 483             final Action action = outActionList1
 484                     .get(outItem);
 485             if (action.getActionChoice() instanceof GroupActionCase) {
 486
 487                 Assert.assertEquals((Long) 6L, ((GroupActionCase) action.getActionChoice()).getGroupAction().getGroupId());
 488
 489             }
 490
 491         }
 492
 493     }
 494 }