private static final FileInfo ACTUAL_FILE_INFO = new FileInfo("actual_file", "actual_content".getBytes(StandardCharsets.UTF_8))
    private static final FileInfo EXPECTED_FILE_INFO = new FileInfo("expected_file", "expected_content".getBytes(StandardCharsets.UTF_8))

    private static final ValueWrapper ACTUAL_STRING_VALUE_WRAPPER = ValueWrapper.create("actual_value")

        when:
        def expectedFile1 = tmpDir.createDir("foo/bar")
        def expectedFile2 = tmpDir.createDir("foo/123")
        buildOptions.installationsFromPaths >> [expectedFile1.absolutePath, expectedFile2.absolutePath]
        def directories = supplier.get()

        then:
        directories.size() == 2
        directories*.location.containsAll(expectedFile1, expectedFile2)

                + "\nUnexpected content for generated actualFile: ${error.message}", expectedXml, actualXml).initCause(error)
        }
    }

    void assertHasExpectedProperties(TestFile actualFile, String expectedFileName) {
        actualFile.assertExists()
        TestFile expectedFile = testDirectory.file("expectedFiles/$expectedFileName").assertIsFile()

            """

                package org.acme

            """
        ).writeScriptPluginAdapterTo(outputDir)

        val expectedFile =
            outputDir.resolve("org/acme/MyScriptPlugin.kt")

        assertThat(
            firstNonBlankLineOf(expectedFile),
            equalTo("package org.acme")
        )
    }

    @Test

    }

    private void assertHasExpectedContents(String path) {
        TestFile actualFile = testDirectory.file(path).assertIsFile()
        TestFile expectedFile = testDirectory.file("expectedFiles/${path}.xml").assertIsFile()

        def expectedXml = expectedFile.text

        def homeDir = executer.gradleUserHomeDir.absolutePath.replace(File.separator, '/')

                @Internal
                List<String> expectedFiles = []

                @TaskAction
                void assertThat() {
                    assert artifacts.files*.name == expectedFiles
                    assert artifactCollection.files*.name == expectedFiles
                }
            }

            task resolveSources(type: Resolve) {

    def expectedFiles = provider {
        [file('${normaliseFileSeparators(shared10.artifactFile.path)}'), file('${normaliseFileSeparators(compileOnlyModule.artifactFile.path)}')] as Set
    }
    doLast {
        assert compileOnlyClasspath.files == expectedFiles.get()
    }
}

task checkCompileClasspath{
    def compileClasspath = configurations.compileClasspath
    def expectedFiles = provider {

                      pjrt_buffer->AcquireExternalReference());
  const size_t expected_size = GetTensorSize(shape, dtype);
  void* opaque_device_memory = ref->OpaqueDeviceMemoryDataPointer();
  auto* tensor_buffer = new PjRtTensorBuffer(
      opaque_device_memory, expected_size, std::move(pjrt_buffer));
  if (ShouldReuseTensor(opaque_device_memory, expected_size, output_tensor)) {
    output_tensor->buf_ = tensor_buffer;
    return absl::OkStatus();

	cases := []struct {
		name          string
		srcFiles      map[string]string
		existingFiles map[string]string
		expectedFiles map[string]string
	}{
		{
			name:          "basic",
			srcFiles:      map[string]string{"istio-cni": "cni111", "istio-iptables": "iptables111"},
			expectedFiles: map[string]string{"istio-cni": "cni111", "istio-iptables": "iptables111"},
		},
		{
			name:          "update binaries",

    }

    static void assertVisits(MinimalFileTree tree, Iterable<String> expectedFiles, Iterable<String> expectedDirs) {
        assertVisits(new FileTreeAdapter(tree, TestFiles.taskDependencyFactory(), TestFiles.patternSetFactory), expectedFiles, expectedDirs)
    }

    static void assertVisits(FileTree tree, Iterable<String> expectedFiles, Iterable<String> expectedDirs) {
        Set files = [] as Set
        Set dirs = [] as Set