"k8s.io/klog/v2"
	"k8s.io/kubernetes/pkg/kubelet/cm/containermap"
	evictionapi "k8s.io/kubernetes/pkg/kubelet/eviction/api"
)

// hardEvictionReservation returns a resourcelist that includes reservation of resources based on hard eviction thresholds.
func hardEvictionReservation(thresholds []evictionapi.Threshold, capacity v1.ResourceList) v1.ResourceList {
	if len(thresholds) == 0 {
		return nil
	}
	ret := v1.ResourceList{}

      path: _test.go$

    {{- if .Base}}

    # TODO(oscr) Remove these excluded directories and fix findings. Due to large amount of findings in different components
    # with different owners it's hard to fix everything in a single pr. This will therefore be done in multiple prs.
    - path: (pkg/volume/*|test/*|azure/*|pkg/cmd/wait*|request/bearertoken/*|metrics/*|filters/*)
      linters:
        - gocritic
    {{- end}}

        BlockingQueue<FileWatchEvent> fileEvents = new ArrayBlockingQueue<>(FILE_EVENT_QUEUE_SIZE);
        try {
            // TODO How can we avoid hard-coding ".gradle" here?
            FileWatcherProbeRegistry probeRegistry = new DefaultFileWatcherProbeRegistry(buildDir ->
                new File(new File(buildDir, ".gradle"), "file-system.probe"));

        JvmOptions jvmOptions = new JvmOptions(fileCollectionFactory);
        // TODO(mlopatkin) figure out a nicer way of handling the presence of agent in the foreground daemon.
        //  Currently it is hard to have a proper "-javaagent:/path/to/jar" in clients that start the daemon, so all code deals with a boolean flag shouldApplyAgent instead.

	// if the consumer falls behind. Unittests will hard timeout in 5m.
	var slices []*discoveryv1.EndpointSlice
	for {
		select {
		case slices = <-h.updated:
			if reflect.DeepEqual(slices, expectedSlices) {
				return
			}
		// Unittests will hard timeout in 5m with a stack trace, prevent that
		// and surface a clearer reason for failure.

== Anti-patterns:

.Don't reference other project tasks directly
--
A frequent anti-pattern to declare cross-project dependencies is below.

This publication model is unsafe and can lead to non-reproducible and hard to parallelize builds.
By declaring a dependency in this way, the task ordering between consumers and producers is not known to Gradle at the time when it is deciding the order of tasks for a given build.

          - "!**/operator/**"
          - "!**/istioctl/**"
          - "!**/tools/bug-report/**"
          # This should only really import operator API, but that is hard to express without a larger refactoring
          - "!**/pkg/kube/**"
          - "!**/pkg/url/**"
          - "!**/pkg/test/framework/**"
          - "!**/tests/fuzz/**"
        deny:

func (c *configFactory) WaitForConfigOrFail(ctx resource.Context, t test.Failer, ns string, yamlText ...string) {
	err := c.WaitForConfig(ctx, ns, yamlText...)
	if err != nil {
		// TODO(https://github.com/istio/istio/issues/37148) fail hard in this case
		t.Log(err)
	}
}

func (c *configFactory) withFilePrefix(prefix string) config.Factory {
	return &configFactory{
		ctx:      c.ctx,
		prefix:   prefix,
		clusters: c.clusters,
	}

		return fmt.Errorf("failed to exec 'git checkout %s': %s: %v", b.revision, output, err)
	}
	if output, err := b.execCommand("git", []string{"reset", "--hard"}, subdir); err != nil {
		return fmt.Errorf("failed to exec 'git reset --hard': %s: %v", output, err)
	}

	volume.SetVolumeOwnership(b, dir, mounterArgs.FsGroup, nil /*fsGroupChangePolicy*/, volumeutil.FSGroupCompleteHook(b.plugin, nil))

//	    go func() {
//	        use(v)  // incorrect, and a data race
//	    }()
//	}
//
// A fix is the same as before. The checker also reports problems
// in goroutines started by golang.org/x/sync/errgroup.Group.
// A hard-to-spot variant of this form is common in parallel tests:
//
//	func Test(t *testing.T) {
//	    for _, test := range tests {
//	        t.Run(test.name, func(t *testing.T) {
//	            t.Parallel()