The deprecated `binResultsDir` property of the `AbstractTestTask` task type has been removed.
Use the `binaryResultsDirectory` property instead.

==== SourceDirectorySet API Cleanup

The deprecated `outputDir` property of the `SourceDirectorySet` type has been removed.
Use the `destinationDirectory` property instead.

==== VersionCatalog API Cleanup

        assertThat(helpResult.output, containsString(outputFor(supportedKotlinJavaVersion(newerJvm.javaVersion!!))))
    }

    private
    val printScriptJavaClassFileMajorVersion = """
        println("Java Class Major Version = ${'$'}{org.gradle.internal.serialize.JavaClassUtil.getClassMajorVersion(this::class.java)}")
    """

    private
    fun outputFor(javaVersion: JavaVersion) =

#include "tensorflow/core/platform/types.h"

namespace tensorflow {
namespace generator {

PathConfig::PathConfig(const string& output_dir, const string& source_dir,
                       const string& api_dir_list,
                       const std::vector<string> op_names)
    : output_path(output_dir), op_names(op_names) {
  api_dirs = str_util::Split(api_dir_list, ",", str_util::SkipEmpty());

type ActionID [HashSize]byte

// An OutputID is a cache output key, the hash of an output of a computation.
type OutputID [HashSize]byte

// Cache is the interface as used by the cmd/go.
type Cache interface {
	// Get returns the cache entry for the provided ActionID.
	// On miss, the error type should be of type *entryNotFoundError.
	//
	// After a success call to Get, OutputFile(Entry.OutputID) must

val copyGr8OutputJarAsGradleWrapperJar by tasks.registering(Copy::class) {
    from(tasks.named<Gr8Task>("gr8R8Jar").flatMap { it.outputJar() })
    into(layout.buildDirectory.dir("libs"))
}

tasks.jar {
    from(tasks.named<Gr8Task>("gr8R8Jar").flatMap { it.outputJar() })
    dependsOn(copyGr8OutputJarAsGradleWrapperJar)

      directory.

  Raises:
    ValueError iff the graph does not contain a valid signature or the file
    prefix tensor is not found in the graph.
  """
  create_empty_output_dir(output_dir)
  v1_builder = builder.SavedModelBuilder(output_dir)

  graph_def = _restore_output_tensor_names(graph_def)
  with session.Session(graph=ops.Graph()) as sess:
    importer.import_graph_def(graph_def, name='')

      function.

  Raises:
    FileExistsError: Iff `output_dir` is not empty and `overwrite` is false.
  """
  dir_not_empty = (
      output_dir is not None
      and file_io.file_exists_v2(output_dir)
      and file_io.list_directory_v2(output_dir)
  )

  if dir_not_empty and not overwrite:
    raise FileExistsError(

				}
			}
		default:
			outputStr := output.String()
			if tc.brokenCertName != "" {
				assert.Contains(t, outputStr, "!MISSING!")
			} else {
				assert.NotContains(t, outputStr, "!MISSING!")
			}

			var lines []string
			for _, line := range strings.SplitAfter(outputStr, "\n") {
				if strings.TrimSpace(line) != "" {
					lines = append(lines, line)
				}

//	    when all tests are complete.
//	    Writes test binary as -c would.
//
//	-mutexprofilefraction n
//	    Sample 1 in n stack traces of goroutines holding a
//	    contended mutex.
//
//	-outputdir directory
//	    Place output files from profiling in the specified directory,
//	    by default the directory in which "go test" is running.
//
//	-trace trace.out

        // [(replica:0,core:0), (replica:1,core:0), ...,
        //  (replica:0,core:1), (replica:1,core:1), ...]
        uint64_t output_id =
            core_id * num_replicas + replica_id + results.size();
        result.replaceAllUsesWith(replicate_op.getResult(output_id));
      }
    }

    // Assume all the replicas have the same structure.
    mlir::TF::TPUPartitionedOutputV2Op first_op = *(ops.begin());