y := x[4:]
		checkBytes("y[1:]", y[1:])
	}
	{
		x := ints
		checkInts("x", x)
		checkInts("x[5:]", x[5:])
		checkInts("x[five:]", x[five:])
		checkInts("x[5:five]", x[5:five])
		checkInts("x[five:5]", x[five:5])
		checkInts("x[five:five]", x[five:five])
		checkInts("x[1:][2:][2:]", x[1:][2:][2:])
		y := x[4:]
		checkInts("y[1:]", y[1:])
	}

        allMessages - (infoMessages + errorMessages)
    }

    void checkOuts(ExecutionResult result) {
        infoMessages.each {List<String> messages ->
            checkOuts(true, result.output, messages, validator)
        }
        errorMessages.each {List<String> messages ->
            checkOuts(true, result.error, messages, validator)
        }
        forbiddenMessages.each {List<String> messages ->

		checkint16(int16(sx), int16(sy))
	}
	if (int64(int8(sx)) == sx || int64(int8(^sx)) == ^sx) && (int64(int8(sy)) == sy || int64(int8(^sy)) == ^sy) {
		checkint8(int8(sx), int8(sy))
	}
}

// Check result of x/y, x%y for various types.

func checkuint(x, y uint) {
	if y == 0 {
		divzerouint(x, y)
		modzerouint(x, y)
		return
	}

		name        string
		mask        []int
		checkBits   []int
		expectedSet bool
	}{
		{
			name:        "Check if any bits from 11 in mask 00 is set",
			mask:        nil,
			checkBits:   []int{0, 1},
			expectedSet: false,
		},
		{
			name:        "Check if any bits from 11 in mask 01 is set",
			mask:        []int{0},
			checkBits:   []int{0, 1},
			expectedSet: true,
		},
		{

Requirements: bash, go

### New Build System (currently for `GOOS == "linux"`)

The new build system uses a Docker container to generate the go files directly
from source checkouts of the kernel and various system libraries. This means
that on any platform that supports Docker, all the files using the new build
system can be generated at once, and generated files will not change based on

        checkoutDir("dep", commits["3.0"].id.name, repo.id).assertDoesNotExist()
    }

    @ToBeFixedForConfigurationCache
    def "removes all checkouts when VCS mappings are removed"() {
        // checkout all versions
        versions.each { version ->
            succeeds("assertVersion", "-PrepoVersion=${version}")
        }
        // mark all versions as unused

* There are some situations where the Kotlin DSL is slower. First use, on clean checkouts or ephemeral CI agents for example, link:{gradle-issues}15886[are known to be slower].
The same applies to the scenario in which something in the _buildSrc_ directory changes, which invalidates build-script caching.

<3> The Kotlin build script applies the Groovy script

[[kotdsl:limitations]]
== Limitations

* The Kotlin DSL is link:{gradle-issues}15886[known to be slower than the Groovy DSL] on first use, for example with clean checkouts or on ephemeral continuous integration agents.
Changing something in the _buildSrc_ directory also has an impact as it invalidates build-script caching.
The main reason for this is the slower script compilation for Kotlin DSL.