// two.
	// There are several constraints:
	// 1. nodeMonitorGracePeriod must be N times more than  the node health signal
	//    update frequency, where N means number of retries allowed for kubelet to
	//    post node status/lease. It is pointless to make nodeMonitorGracePeriod
	//    be less than the node health signal update frequency, since there will

      (TFL_Relu6Op $x),
      [(IsConstantValueOf<6> $y)]>;

// For both relu1 and relu_0_to_1, the min/max operators commute,
// so there are two possible orderings we need to rewrite.
// Concretely, `m < n -> max(m, min(n, x)) = min(m, max(m, x))`.
// Proof:
// case (x <= m)
//   max(m, min(n, x)) = max(m, m) = m and
//   min(n, max(m, x)) = min(n, m) = m
// case (m < x < n)

		// Constant flag value.
		// Note: there's an "unordered" outcome for floating-point
		// comparisons, but we don't use such a beast yet.
		// This op is for temporary use by rewrite rules. It
		// cannot appear in the generated assembly.
		{name: "FlagConstant", aux: "FlagConstant"},

		// (InvertFlags (CMP a b)) == (CMP b a)
		// InvertFlags is a pseudo-op which can't appear in assembly output.

include::sample[dir="snippets/testing/junitplatform-mix/groovy",files="build.gradle[tags=vintage-dependencies]"]
====

In this way, you can use `gradle test` to test JUnit 3/4 tests on JUnit Platform, without the need to rewrite them.

[[filtering_test_engine]]
=== Filtering test engine

JUnit Platform allows you to use different test engines. JUnit currently provides two `TestEngine` implementations out of the box:

----

Once done, make sure to run <<#sec:verification-update,the generation command again>> so that the key is processed by Gradle.
This will do the following:

* Add a standard header to the key
* Rewrite the key using Gradle's own format, which trims the key to the bare minimum
* Move the key to its sorted location, keeping the file reproducible

[[sec:add-binary-keyring]]
=== Adding keys to the binary keyring

            'CUDNN_INSTALL_PATH',
            'NCCL_INSTALL_PATH',
            'NCCL_HDR_PATH',
            'TENSORRT_INSTALL_PATH'
        ]
        # Note: set_action_env_var above already writes to bazelrc.
        for name in cuda_env_names:
          if name in environ_cp:
            write_action_env_to_bazelrc(name, environ_cp[name])
        break

			unicode.SimpleFold(re.Rune[1]) == re.Rune[0] {
		// Case-insensitive rune like [Aa] or [Δδ].
		if p.maybeConcat(re.Rune[0], p.flags|FoldCase) {
			return nil
		}

		// Rewrite as (case-insensitive) literal.
		re.Op = OpLiteral
		re.Rune = re.Rune[:1]
		re.Flags = p.flags | FoldCase
	} else {
		// Incremental concatenation.
		p.maybeConcat(-1, 0)
	}

	switch rsa.Addr.Family {
	case AF_UNIX:
		pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
		sa := new(SockaddrUnix)
		if pp.Path[0] == 0 {
			// "Abstract" Unix domain socket.
			// Rewrite leading NUL as @ for textual display.
			// (This is the standard convention.)
			// Not friendly to overwrite in place,
			// but the callers below don't care.
			pp.Path[0] = '@'
		}

((CMP|CMPW|CMPU|CMPWU) x y) && canonLessThan(x,y) => (InvertFlags ((CMP|CMPW|CMPU|CMPWU) y x))

// n is always a zero-extended uint16 value, so n & z is always a non-negative 32 or 64 bit value.
// Rewrite to a cmp int64(0) to lower into ANDCCconst in the latelower pass.
(CMP(W|U|WU)const [0] a:(ANDconst [n] z)) => (CMPconst [0] a)

// SETBC auxInt values 0=LT 1=GT 2=EQ   Crbit==1 ? 1 : 0

	}
	return h.count
}

// mapinitnoop is a no-op function known the Go linker; if a given global
// map (of the right size) is determined to be dead, the linker will
// rewrite the relocation (from the package init func) from the outlined
// map init function to this symbol. Defined in assembly so as to avoid
// complications with instrumentation (coverage, etc).
func mapinitnoop()