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