list == checkable(['bar'])
    }

    def "can remove all elements"() {
        when:
        mutate {
            add 'foo'
            add 'bar'
            clear()
        }

        then:
        def list = registry.realize(collectionPath, collectionType)
        list == checkable([])
    }

    def "can removeAll elements"() {

            add 'foo'
            add 'bar'
            add 'baz'
            remove(1)
        }

        then:
        def list = registry.realize(collectionPath, collectionType)
        list == checkable(['foo', 'baz'])
    }

    def "can add using index"() {
        when:
        mutate {
            add 'foo'
            add(0, 'bar')
        }

        then:

    @Managed
    static interface Internal {
        Set<String> getItems()
    }

    @Override
    Class<?> holderType() {
        Internal
    }

    @Override
    Set<String> checkable(List<String> list) {
        new LinkedHashSet<String>(list)
    }

 * limitations under the License.
 */

package org.gradle.api;

import org.gradle.platform.base.ComponentSpec;

import javax.annotation.Nullable;

/**
 * A {@link ComponentSpec} that is directly checkable via a specified task.
 */
@Incubating
public interface CheckableComponentSpec extends ComponentSpec {

    /**
     * Returns the task responsible for checking this component.
     */
    @Nullable

// errorcheck -0 -d=ssa/check_bce/debug=3

//go:build amd64 && !gcflags_noopt

// Copyright 2016 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test that the compiler does bounds check elimination as expected.
// This avoids accidental regressions.

package main

import "encoding/binary"

func f0(a []int) {

My CI build tasks
-----------------
checkAll - Runs checks for all projects (CI)

My global build tasks
---------------------
qualityCheckApp - Runs checks on app (globally)
----

If we run the `:checkAll` task, we see that it compiles all the code and runs the code quality checks (including `spotbug`):

[source,text]
----
$ ./gradlew :checkAll

			return
		}
	})
}

-- check_file/main.go --
package main

import (
	"bytes"
	"fmt"
	"os"
	"path/filepath"
	"regexp"
	"strconv"
)

func checkFile(name, expected string) (bool, error) {
	data, err := os.ReadFile(name)
	if err != nil {
		return false, err
	}
	for _, line := range bytes.Split(data, []byte("\n")) {
		m := valRe.FindSubmatch(line)
		if m == nil {

defaultTasks("run")

// tag::run[]
tasks.register("run") {
    dependsOn(gradle.includedBuild("my-app").task(":app:run"))
}
// end::run[]

tasks.register("checkAll") {
    dependsOn(gradle.includedBuild("my-app").task(":app:check"))
    dependsOn(gradle.includedBuild("my-utils").task(":number-utils:check"))
    dependsOn(gradle.includedBuild("my-utils").task(":string-utils:check"))

defaultTasks 'run'

// tag::run[]
tasks.register('run') {
    dependsOn gradle.includedBuild('my-app').task(':app:run')
}
// end::run[]

task checkAll {
    dependsOn gradle.includedBuild('my-app').task(':app:check')
    dependsOn gradle.includedBuild('my-utils').task(':number-utils:check')
    dependsOn gradle.includedBuild('my-utils').task(':string-utils:check')

				if !checkVal(fv.Args[i], gv.Args[i]) {
					return false
				}
			}
		}
		return valcor[fv] == gv && valcor[gv] == fv
	}
	blkcor := make(map[*Block]*Block)
	var checkBlk func(fb, gb *Block) bool
	checkBlk = func(fb, gb *Block) bool {
		if blkcor[fb] == nil && blkcor[gb] == nil {
			blkcor[fb] = gb
			blkcor[gb] = fb
			// ignore ids
			if fb.Kind != gb.Kind {
				return false
			}