// Configuration for the resource quotas for the CNI DaemonSet.
message ResourceQuotas {
  // Controls whether to create resource quotas or not for the CNI DaemonSet.
  google.protobuf.BoolValue enabled = 1;

  // The hard limit on the number of pods in the namespace where the CNI DaemonSet is deployed.
  int64 pods = 2;
}

// Configuration for CPU or memory target utilization for HorizontalPodAutoscaler target.

	// of the limit.
	//
	// The purpose of shooting lower than the limit is to ensure that, once
	// close to the limit, the scavenger is working hard to maintain it. If
	// we have a memory limit set but are far away from it, there's no harm
	// in leaving up to 100-retainExtraPercent live, and it's more efficient
	// anyway, for the same reasons that retainExtraPercent exists.
	reduceExtraPercent = 5

                    module('org:lib:1.1')
                }
            }
        }
    }

    @Issue("https://github.com/gradle/gradle/issues/13658")
    def "constraint shouldn't be converted to hard dependency when a dependency substitution applies on an external module"() {
        def fooModule = mavenRepo.module("org", "foo", "1.0")
        mavenRepo.module("org", "platform", "1.0")
            .asGradlePlatform()

        // If none of the incoming edges are transitive, remove previous state and do not traverse.
        // If not traversed before, simply add all selected outgoing edges (either hard or pending edges)
        // If traversed before:
        //      If net exclusions for this node have not changed, ignore

		t.Log("too few samples on Windows (golang.org/issue/10842)")
		return p, false
	}

	// Check that we got a reasonable number of samples.
	// We used to always require at least ideal/4 samples,
	// but that is too hard to guarantee on a loaded system.
	// Now we accept 10 or more samples, which we take to be
	// enough to show that at least some profiling is occurring.

  # interface (trying to add routes on the Ethernet interface at this point just
  # results in "New-NetRoute : Element not found" errors). I don't know what's
  # up with that, but since it's hard to know what's the right thing to do here
  # we just try to add the route on all of the network adapters.
  Get-NetAdapter | ForEach-Object {
    $adapter_index = $_.InterfaceIndex
    New-NetRoute `

                                Version.V20,
                                prefix + prefix2 + "systemPath",
                                key,
                                "should use a variable instead of a hard-coded path " + sysPath,
                                dependency);
                    } else if (sysPath.contains("${basedir}") || sysPath.contains("${project.basedir}")) {
                        addViolation(

		// a very clear signal. Making the two files the same may cause
		// surprises if programs close os.Stdout but expect to be able
		// to continue to write to os.Stderr, but it's hard to see why a
		// test would think it could take over global state that way.
		//
		// This fix only helps programs where the output is coming directly
		// from Go code. It does not help programs in which a subprocess is

		// dump from a timed-out test process scales roughly with the overall
		// running time of the test.
		//
		// This is probably too generous when the timeout is very long, but it seems
		// better to hard-code a scale factor than to hard-code a constant delay.
		if wd := testTimeout / 10; wd < 5*time.Second {
			testWaitDelay = 5 * time.Second
		} else {
			testWaitDelay = wd
		}

This means that tasks and operations should be deferred until they are actually needed rather than executed eagerly.

Many examples in this chapter use hard-coded paths as string literals.
This makes them easy to understand, but it is not good practice.
The problem is that paths often change, and the more places you need to change them, the more likely you will miss one and break the build.