// Trace represents an execution trace for testing.
//
// It does a little bit of work to ensure that the produced trace is valid,
// just for convenience. It mainly tracks batches and batch sizes (so they're
// trivially correct), tracks strings and stacks, and makes sure emitted string
// and stack batches are valid. That last part can be controlled by a few options.
//
// Otherwise, it performs no validation on the trace at all.
type Trace struct {

        "//tensorflow/compiler/mlir/tfrt/ir:tfrt_fallback_async_opdefs",
        "//tensorflow/compiler/mlir/tfrt/ir:tfrt_fallback_sync_opdefs",
        "//tensorflow/core:test",
        "//tensorflow/core/platform:resource_loader",
        "//tensorflow/core/tfrt/fallback:cost_recorder",
        "@com_google_absl//absl/container:flat_hash_map",
        "@com_google_googletest//:gtest_main",

	apiVersionTooOld  = "no kind \"KubeSchedulerConfiguration\" is registered for" +
		" version \"kubescheduler.config.k8s.io/v1alpha1\""

	// schedulerConfigMinimalCorrect is the minimal
	// correct scheduler config
	schedulerConfigMinimalCorrect = `
apiVersion: kubescheduler.config.k8s.io/v1
kind: KubeSchedulerConfiguration`

	// schedulerConfigDecodeErr is the scheduler config

    @Rule final TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())

    def 'asJvmArg with default arguments assembles correct string'() {
        setup:
        agent.supportsJmx() >> true
        agent.supportsInclNoLocationClasses() >> true
        agent.jar >> temporaryFolder.file('fakeagent.jar')

Of course, the attackers would not try all this by hand, they would write a program to do it, possibly with thousands or millions of tests per second. And would get just one extra correct letter at a time.

But doing that, in some minutes or hours the attackers would have guessed the correct username and password, with the "help" of our application, just using the time taken to answer.

#### Fix it with `secrets.compare_digest()`

    srcs = ["grappler_test.cc"],
    deps = [
        ":grappler",
        "//tensorflow/c:c_api_internal",
        "//tensorflow/c:tf_buffer_internal",
        "//tensorflow/core:framework",
        "//tensorflow/core:test",
        "//tensorflow/core:test_main",
        "//tensorflow/core/grappler:grappler_item",
        "//tensorflow/core/grappler/clusters:single_machine",
        "//tensorflow/core/grappler/costs:graph_properties",

        'provider' | { ScopedServiceRegistry it -> it.addProvider(new MultiScopedServiceProvider()) }
    }

    def "succeeds when registering a service in the correct scope"() {
        given:
        def registry = scopedRegistry(Scope.BuildTree)
        def service = new BuildTreeScopedService()

        when:
        registry.add(service)

        then:

class DefaultGroovyJavaJointCompileSpecFactoryTest extends Specification {

    @Rule
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())

    def "produces correct spec type" () {
        CompileOptions options = TestUtil.newInstance(CompileOptions.class, TestUtil.objectFactory())
        options.fork = fork

        "//tensorflow/compiler/mlir/quantization/common:test_base",
        "//tensorflow/compiler/mlir/quantization/common/quantization_lib",
        "//tensorflow/compiler/mlir/tensorflow",
        "//tensorflow/core:test",
        "@com_google_absl//absl/strings:string_view",
        "@com_google_googletest//:gtest_main",
        "@llvm-project//mlir:FuncDialect",
        "@llvm-project//mlir:IR",
        "@llvm-project//mlir:Support",

// that this is nearly always a mistake.
//
// For example:
//
//	start := time.Now()
//	...
//	defer recordLatency(time.Since(start)) // error: call to time.Since is not deferred
//
// The correct code is:
//
//	defer func() { recordLatency(time.Since(start)) }()