t.Fatalf("Current: %v", err)
		} else {
			t.Skipf("skipping: %v", err)
		}
	}

	// TODO: Lookup() has a fast path that calls Current() and returns if the
	// usernames match, so this test does not exercise very much. It would be
	// good to try and test finding a different user than the current user.
	got, err := Lookup(want.Username)
	if err != nil {
		t.Fatalf("Lookup: %v", err)
	}
	compare(t, want, got)
}

import static org.gradle.internal.enterprise.GradleEnterprisePluginConfig.BuildScanRequest.SUPPRESSED

// Note: most of the other tests are structure to implicitly also exercise configuration caching
// This tests some specific aspects, and serves as an early smoke test.
@Requires(IntegTestPreconditions.NotConfigCached)

  DISABLE_ADMISSION_PLUGINS="ServiceAccount,DefaultStorageClass,DefaultTolerationSeconds,MutatingAdmissionWebhook,ValidatingAdmissionWebhook,StorageObjectInUseProtection"

  # Include RBAC (to exercise bootstrapping), and AlwaysAllow to allow all actions
  AUTHORIZATION_MODE="RBAC,AlwaysAllow"

  # Enable features
  ENABLE_FEATURE_GATES=""

  "${THIS_PLATFORM_BIN}/kube-apiserver" \
    --bind-address="127.0.0.1" \

			quota.ResourceVersion = fmt.Sprintf("%d", i)
			quota.Namespace = action.GetNamespace()
			resourceQuotaList.Items = append(resourceQuotaList.Items, *quota)
		}
		// make the handler slow so concurrent calls exercise the singleflight
		time.Sleep(time.Second)
		return true, resourceQuotaList, nil
	})

	wg := sync.WaitGroup{}
	for i := 0; i < 10; i++ {
		wg.Add(2)
		// simulating concurrent calls after a cache failure

- however if you are a library, adding <<dependency_downgrade_and_exclude.adoc#sec:excluding-transitive-deps,exclusions>> may prevent consumers from working properly, because they would exercise a path of the code that you don't

Always keep in mind that the solution you choose to fix a problem can "leak" to your consumers.

)

type fakeMetrics struct {
	original validation.ValidationMetrics
	realSum  time.Duration
}

func (f *fakeMetrics) ObserveRatchetingTime(d time.Duration) {
	// Hardcode 1 ns duration for testing to exercise all buckets
	f.original.ObserveRatchetingTime(1 * time.Nanosecond)
	f.realSum += d
}

func (f *fakeMetrics) Reset() []metrics.Registerable {
	f.realSum = 0
	originalResettable, ok := f.original.(resettable)

TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR
PURPOSE. Each Recipient is solely responsible for determining the
appropriateness of using and distributing the Program and assumes all
risks associated with its exercise of rights under this Agreement,
including but not limited to the risks and costs of program errors,
compliance with applicable laws, damage to or loss of data, programs

// The nfsPlugin is used to store the volumeConfig and give it, when needed, to the func that creates NFS Recyclers.
// Tests that exercise recycling should not use this func but instead use ProbeRecyclablePlugins() to override default behavior.
func ProbeVolumePlugins(volumeConfig volume.VolumeConfig) []volume.VolumePlugin {
	return []volume.VolumePlugin{
		&nfsPlugin{

// methods in terms of helpers that would use them.
// (In general, implementing these methods using the package fs helpers
// is redundant and unnecessary, but having the methods may make
// MapFS exercise more code paths when used in tests.)
type fsOnly struct{ fs.FS }

func (fsys MapFS) ReadFile(name string) ([]byte, error) {
	return fs.ReadFile(fsOnly{fsys}, name)
}

# This test uses the fake toolchain switch support in cmd/go/internal/toolchain.Switch
# to exercise all the version selection logic without needing actual toolchains.
# See gotoolchain_net.txt and gotoolchain_path.txt for tests of network and PATH toolchains.

env TESTGO_VERSION=go1.500
env TESTGO_VERSION_SWITCH=switch

# GOTOOLCHAIN=auto runs default toolchain without a go.mod or go.work
env GOTOOLCHAIN=auto
go version
stdout go1.500