"groups" : [ {
      "testProject" : "largeEmptyMultiProjectDeclarativeDsl",
      "coverage" : {
        "per_day" : [ "linux", "macOs", "windows" ]
      }
    } ]
  }, {
    "testId" : "org.gradle.performance.experiment.declarativedsl.DeclarativeDslFirstUsePerformanceTest.cold daemon",
    "groups" : [ {
      "testProject" : "largeEmptyMultiProjectDeclarativeDsl",

            }
            this.groupSid = new SID(domainId, groupId);

            // Compute Group IDs with Domain ID to get Group SIDs
            this.groupSids = new SID[groups.length];
            for ( int i = 0; i < groups.length; i++ ) {
                this.groupSids[ i ] = new SID(domainId, groups[ i ].getId());
            }
        }
        catch ( IOException e ) {

    groups.add(ImmutableList.copyOf(group));
    return this;
  }

  public void test() {
    for (int groupNumber = 0; groupNumber < groups.size(); groupNumber++) {
      ImmutableList<T> group = groups.get(groupNumber);
      for (int itemNumber = 0; itemNumber < group.size(); itemNumber++) {
        // check related items in same group

		path, prefix, suffix string
		expected             string
	}{
		{"config/iam/groups/foo.json", "config/iam/groups/", ".json", "foo"},
		{"config/iam/groups/./foo.json", "config/iam/groups/", ".json", "foo"},
		{"config/iam/groups/foo/config.json", "config/iam/groups/", "/config.json", "foo"},
		{"config/iam/groups/foo/config.json", "config/iam/groups/", "config.json", "foo"},
	}
	for i, test := range specs {

### Group membership search

MinIO can be optionally configured to find the groups of a user from AD/LDAP by specifying the following variables:

```
MINIO_IDENTITY_LDAP_GROUP_SEARCH_FILTER     (string)    search filter for groups e.g. "(&(objectclass=groupOfNames)(memberUid=%s))"
MINIO_IDENTITY_LDAP_GROUP_SEARCH_BASE_DN    (list)      ";" separated list of group search base DNs e.g. "dc=myldapserver,dc=com"

        protected final String name;

        protected String[] groups;

        protected String[] roles;

        protected String[] permissions;

        protected OpenIdUser(final String name, final String[] groups, final String[] roles) {
            this.name = name;
            this.groups = groups;
            this.roles = roles;
        }

        @Override

}

verify_iam_content_in_new_minio() {
	output=$(mc idp ldap policy entities new-minio --json)

	groups=$(echo "$output" | jq -r '.result.policyMappings[] | select(.policy == "readwrite") | .groups[]')
	if [ "$groups" != "cn=project.c,ou=groups,ou=swengg,dc=min,dc=io" ]; then
		echo "Failed to verify groups: $groups"
		exit 1
	fi

		return "", nil, errRet
	}

	// Bind to the lookup user account again to perform group search.
	if err = l.LDAP.LookupBind(conn); err != nil {
		return "", nil, err
	}

	// User groups lookup.
	groups, err := l.LDAP.SearchForUserGroups(conn, username, bindDN)
	if err != nil {
		return "", nil, err
	}

	return bindDN, groups, nil
}

// GetExpiryDuration - return parsed expiry duration.

     * target server where keys are SIDs representing an account and each value
     * is an ArrayList of SIDs represents the local groups that the account is
     * a member of.
     * <p/>
     * This method is designed to assist with computing access control for a
     * given user when the target object's ACL has local groups. Local groups

				}
			}
			if len(grps) > 0 {
				args["groups"] = grps
			}
		}
	}

	// if not claim groups are available use the one with auth.Credentials
	if _, ok := args["groups"]; !ok {
		if len(groups) > 0 {
			args["groups"] = groups
		}
	}

	return args
}

// PolicyToBucketAccessPolicy converts a MinIO policy into a minio-go policy data structure.