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"() {

	"k8s.io/klog/v2"
)

// UnsupportedConfigVersionError is a special error type returned whenever we encounter too old config version
type UnsupportedConfigVersionError struct {
	// OldVersion is the config version that is causing the problem
	OldVersion schema.GroupVersion

	// CurrentVersion describes the natively supported config version
	CurrentVersion schema.GroupVersion

	// Document points to the YAML/JSON document that caused the problem

# Regression test for https://golang.org/issue/48511:
# requirement minimization was accidentally replacing previous
# versions of the main module, causing dependencies to be
# spuriously dropping during requirement minimization and
# leading to an infinite loop.

cp go.mod go.mod.orig
go mod tidy
cmp go.mod go.mod.orig

go get -u=patch ./...
cmp go.mod go.mod.want

-- go.mod --
module example.net/m

go 1.16

replace (

// did not. This mismatch meant that s would be marked live
// (and therefore initialized) at the call to f, but the register optimizer
// would optimize away the initialization of s before f, causing the
// garbage collector to use unused data.
// The register optimizer has been changed to respect the
// same "address taken" flag that the liveness analysis uses,
// even if it cannot see any address being taken in the actual

// 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

	}

	// Taint node with NotReady taint at creation. This is needed to make sure
	// that nodes are added to the cluster with the NotReady taint. Otherwise,
	// a new node may receive the taint with some delay causing pods to be
	// scheduled on a not-ready node. Node controller will remove the taint
	// when the node becomes ready.
	addNotReadyTaint(node)
	return nil
}

func addNotReadyTaint(node *api.Node) {

// 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.

In Kubernetes clusters in version 1.10.0 or later, fluentd-gcp DaemonSet can be
manually scaled. This is useful e.g. when applications running in the cluster
are sending a large volume of logs (i.e. over 100kB/s), causing fluentd-gcp to
fail with OutOfMemory errors. Conversely, if the applications aren't generating
a lot of logs, it may be useful to reduce the amount of resources consumed by