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