file("settings.gradle") << """
            rootProject.name = 'test'
        """
    }

    def cleanup() {
        // unstopped instances of ProjectBuilderImpl projects leak build operations
        // causing other integration tests to sporadically fail.
        if (project != null) {
            ProjectBuilderImpl.stop(project)
        }
    }

    def "can resolve remote dependencies"() {

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

package main

// A C function returning a value on the Go stack could leave the Go
// stack marked as uninitialized, potentially causing a later error
// when the stack is used for something else. Issue 26209.

/*
#cgo LDFLAGS: -fsanitize=memory
#cgo CPPFLAGS: -fsanitize=memory

#include <stdint.h>
#include <stdlib.h>
#include <string.h>

     */
    Optional<Throwable> getDisabledReason(String repositoryId);

    /**
     * Attempts to disable the repository with the given id, recording the exception causing it to be disabled, if
     * that exception is deemed critical.
     *
     * @param repositoryId the id of the repository to disable
     * @param throwable the reason why the repository is being disabled

// If we have a receiver of pointer to type parameter type (below: *T)
// we don't have any methods, like for interfaces.
type C[T any] interface {
    m()
}

// using type bound C
func _[T C[T]](x *T) {
	x.m /* ERROR "x.m undefined" */ ()
}

// using an interface literal as bound
func _[T interface{ m() }](x *T) {
	x.m /* ERROR "x.m undefined" */ ()
}

func f2[_ interface{ m1(); m2() }]() {}

type T struct{}

 *
 */
public interface SettingsReader {

    /**
     * The key for the option to enable strict parsing. This option is of type {@link Boolean} and defaults to {@code
     * true}. If {@code false}, unknown elements will be ignored instead of causing a failure.
     */
    String IS_STRICT = "org.apache.maven.settings.io.isStrict";

    /**
     * Reads the settings from the specified file.

     * and where distinguishing such passed-on-retry outcomes is important.
     * This is the case for the Jenkins CI server and its Flaky Test Handler plugin.
     *
     * This value defaults to {@code false}, causing each test execution to be a discrete {@code <testcase>}.
     *

	}
}

func TestCrashHandler(t *testing.T) {
	testCrashHandler(t, false)
}

func testDeadlock(t *testing.T, name string) {
	// External linking brings in cgo, causing deadlock detection not working.
	testenv.MustInternalLink(t, false)

	output := runTestProg(t, "testprog", name)
	want := "fatal error: all goroutines are asleep - deadlock!\n"
	if !strings.HasPrefix(output, want) {

            val source: Program.Plugins? = null
        ) : StageTransition, Instruction()

        /**
         * An instruction that marks the transition from stage 1 to stage 2 by causing the
         * target scope to be closed thus making the resolved classpath available to stage 2.
         *
         * A valid [Static] program must contain one and only one [StageTransition] instruction.
         */

public abstract class AbstractJVMVersionTooNewFailureDescriber extends AbstractResolutionFailureDescriber<IncompatibleGraphVariantFailure> {
    /**
     * Returns the JVM version used in the comparison against the library that is causing the failure.
     *
     * @param failure the failure
     * @return the JVM version that is incompatible
     */
    protected abstract JavaVersion getJVMVersion(IncompatibleGraphVariantFailure failure);

# Regression test for https://go.dev/issue/53955.
# New remote tags were erroneously added to the local clone of a repo
# only *after* extracting version information for a locally-cached commit,
# causing the version information to have incomplete Tags and Version fields.

[short] skip 'constructs a local git repo'
[!git] skip
[!net:github.com] skip 'does not actually use github.com because of insteadOf, but silence network check just in case'