//
// Functions that abruptly terminate a test, such as the Fatal, Fatalf, FailNow, and
// Skip{,f,Now} methods of *testing.T, must be called from the test goroutine itself.
// This checker detects calls to these functions that occur within a goroutine
// started by the test. For example:
//
//	func TestFoo(t *testing.T) {
//	    go func() {
//	        t.Fatal("oops") // error: (*T).Fatal called from non-test goroutine

limitations under the License.
*/

package inuserns

import libcontaineruserns "github.com/opencontainers/runc/libcontainer/userns"

// RunningInUserNS detects whether the current process is running in a user namespace.
func RunningInUserNS() bool {
	return libcontaineruserns.RunningInUserNS()

// license that can be found in the LICENSE file.

// Make sure we don't get an index out of bounds error
// while trying to print a map that is concurrently modified.
// The runtime might complain (throw) if it detects the modification,
// so we have to run the test as a subprocess.

package main

import (
	"os/exec"
	"strings"
)

func main() {

 * limitations under the License.
 */

package org.gradle.cache.internal.btree

import spock.lang.Specification

class BlockPointerTest extends Specification {

    def "detects corrupt pointers"() {
        when:
        BlockPointer.pos(-10)
        then:
        def e = thrown(CorruptedCacheException)
        e.message.contains("-10")
    }

    public static final int FILE_NOTIFY_CHANGE_ATTRIBUTES = 0x00000004;

    /**
     * Any file-size change in the watched directory or subtree causes a change notification wait operation to return.
     * The operating system detects a change in file size only when the file is written to the disk. For operating
     * systems that use extensive caching, detection occurs only when the cache is sufficiently flushed.s
     */

package org.gradle.launcher.continuous

import org.gradle.integtests.fixtures.AbstractContinuousIntegrationTest

class BuildScriptChangesContinuousBuildIntegrationTest extends AbstractContinuousIntegrationTest {

    def "detects changes to #buildFileName scripts"() {
        given:
        def markerFile = file("input/marker")
        markerFile.text = "original"

        file(buildFileName) << """
            tasks.register("myTask") {

class TaskFromPluginValidationIntegrationTest extends AbstractIntegrationSpec implements ValidationMessageChecker {

    def setup() {
        expectReindentedValidationMessage()
    }

    def "detects that a problem is from a task declared in a precompiled script plugin"() {
        withPrecompiledScriptPlugins()
        def pluginFile = file("buildSrc/src/main/groovy/test.gradle.demo.plugin.gradle")

stderr 'go: rsc.io/quote@v1.5.2: verifying go.mod: checksum mismatch'
stderr 'SECURITY ERROR\n'

rm go.sum

# switching to truthful sumdb detects timeline inconsistency
cp go.mod.orig go.mod
env GOSUMDB=$sumdb
! go get rsc.io/fortune
stderr 'SECURITY ERROR\ngo.sum database server misbehavior detected!'
stderr 'proof of misbehavior:'

# removing the cached wrong tree head and cached tiles clears the bad data

[[sec:build_phases]]
== Build Phases

A Gradle build has three distinct phases.

image::author-gradle-1.png[]

Gradle runs these phases in order:

Phase 1. Initialization::
- Detects the `settings.gradle(.kts)` file.
- Creates a link:{groovyDslPath}/org.gradle.api.initialization.Settings.html[`Settings`] instance.
- Evaluates the settings file to determine which projects (and included builds) make up the build.

            task waitForUserChanges {
                doLast {
                    ${server.callFromBuild("userInput")}
                }
            }
        """
    }

    def "detects input file change just before the task is executed"() {
        def inputFile = file("input.txt")
        buildFile << """
            def inputFile = file("input.txt")
            def outputFile = file("build/output.txt")