verify(sorted[0]) {
            selected 'group:a:1.0'
            isHeader()
            noMoreChildren()
        }
        verify(sorted[1]) {
            selected 'group:a:1.0'
            isNotHeader()
            hasChild('group:b:1.0') {
                noMoreChildren()
            }
            hasChild('group:d:1.0') {
                noMoreChildren()
            }

        settingsFile << "rootProject.name = 'test'"
        buildFile << twoGroupsTasks()

        when:
        succeeds "tasks", "--group=Group 1", "--groups=Group 2"

        then:
        output.contains("$GROUP_1 tasks")
        output.contains("$GROUP_2 tasks")
        !output.contains("Build Setup")
    }

        GroupCQ cq = new GroupCQ();
        if (queryLambda != null) {
            queryLambda.callback(cq);
        }
        FilterAggregationBuilder builder = regFilterA(name, cq.getQuery());
        if (opLambda != null) {
            opLambda.callback(builder);
        }
        if (aggsLambda != null) {
            GroupCA ca = new GroupCA();
            aggsLambda.callback(ca);

        when:
        result.rethrowFailure()

        then:
        DefaultMultiCauseException e = thrown()
        e.cause instanceof ModuleVersionResolveException
        e.cause.message.contains "project :root > group:a:1.0"
        e.cause.message.contains "project :root > group:b:1.0"

	"github.com/pkg/sftp"
	"golang.org/x/crypto/ssh"
)

const (
	kexAlgoDH1SHA1                = "diffie-hellman-group1-sha1"
	kexAlgoDH14SHA1               = "diffie-hellman-group14-sha1"
	kexAlgoDH14SHA256             = "diffie-hellman-group14-sha256"
	kexAlgoDH16SHA512             = "diffie-hellman-group16-sha512"
	kexAlgoECDH256                = "ecdh-sha2-nistp256"
	kexAlgoECDH384                = "ecdh-sha2-nistp384"

        GroupCQ mustNotQuery = new GroupCQ();
        GroupCQ filterQuery = new GroupCQ();
        boolLambda.callback(mustQuery, shouldQuery, mustNotQuery, filterQuery);
        if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries() || filterQuery.hasQueries()) {
            BoolQueryBuilder builder = regBoolCQ(mustQuery.getQueryBuilderList(), shouldQuery.getQueryBuilderList(),

        if (resolvedContainer is Ok && obj is Ok) {
            DataAdditionRecord(resolvedContainer.objectOrigin, obj.objectOrigin)
        } else null
    }.groupBy({ it.container }, valueTransform = { it.dataObject })

    private
    val allReceiversResolved = run {
        val allReceiverReferences = resolutionResult.conventionAdditions.map { it.container } +

    } else {
        listOf(performanceTestSpec.performanceTestType)
    }
    return performanceTestConfigurations.flatMap { configuration ->
        configuration.groups
            .filter { group ->
                performanceTestTypes.any { type ->
                    group.performanceTestTypes[type]?.contains(performanceTestSpec.os) == true
                }
            }

   * described in the class documentation.
   *
   * @throws NullPointerException if any of {@code elements} is null
   * @since 6.0
   */
  public static <E> ImmutableMultiset<E> copyOf(E[] elements) {
    return copyFromElements(elements);
  }

  /**
   * Returns an immutable multiset containing the given elements, in the "grouped iteration order"

        sort([]) == []
        sort([] as Set) == []
    }

    def "grouping"() {
        expect:
        groupBy([1, 2, 3], transformer { "a" }) == ["a": [1, 2, 3]]
        groupBy(["a", "b", "c"], transformer { it.toUpperCase() }) == ["A": ["a"], "B": ["b"], "C": ["c"]]
        groupBy([], transformer { throw new AssertionError("shouldn't be called") }).isEmpty()
    }
    def unpack() {
        expect: