doLast {
                    assert files*.name == ["foo-1.0.jar", "${expectedFile}"]
                }
            }
        """

        expect:
        succeeds("resolve")

        where:
        artifactDeclaration | expectedFile
        ""                  | "transitive-1.0-cls.jar"
        '"extension": "",'  | "transitive-1.0-cls"
    }

        MinimalFileSet fileSet = Mock()
        FileCollectionAdapter adapter = new FileCollectionAdapter(fileSet)
        def expectedFiles = [new File('a'), new File('b')] as Set

        when:
        def files = adapter.files

        then:
        files == expectedFiles
        1 * fileSet.getFiles() >> expectedFiles
        0 * _._
    }

    def visitDependenciesDelegatesToTargetCollectionWhenItImplementsBuildable() {

                @Internal
                List<String> expectedFiles = []

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

            task resolveSources(type: Resolve) {

// also owns a PjRtBuffer for XLA kernel's usage.
class PjRtTensorBuffer : public TensorBuffer {
 public:
  PjRtTensorBuffer(const void* ptr, size_t expected_size,
                   std::unique_ptr<xla::PjRtBuffer> pjrt_buffer)
      : TensorBuffer(const_cast<void*>(ptr)),
        expected_size_(expected_size),
        pjrt_buffer_(std::move(pjrt_buffer)) {}

  size_t size() const override { return expected_size_; }

        }

        then:
        1 * visitor.visitFile(_) >> { FileVisitDetails details ->
            with(details) {
                file == expectedFile
                !directory
                size == expectedFile.size()
                name == expectedFile.name
                path == "dir1/file2"
                relativePath.segments == ["dir1", "file2"]
            }
        }

        then:

            compare("files", actualFiles, expectedFiles)

            actualFiles = findLines(configDetails, 'file-filtered')
            compare("files (filtered)", actualFiles, expectedFiles)

            actualFiles = findLines(configDetails, 'incoming-file')
            compare("incoming.files", actualFiles, expectedFiles)

            actualArtifacts = findLines(configDetails, 'incoming-artifact')

	}
}

// checkResult checks if resultFile is equal to expectedFile at each tick until timeout
func checkResult(result, expected string) error {
	resultFile, err := os.ReadFile(result)
	if err != nil {
		return fmt.Errorf("couldn't read result: %v", err)
	}
	expectedFile, err := os.ReadFile(expected)
	if err != nil {
		return fmt.Errorf("couldn't read expected: %v", err)
	}

            switch (diff) {
                case FILE: {
                    Path expectedFile = buildDir.relativize(expected.getFile().toPath());
                    Path actualFile = buildDir.relativize(actual.getFile().toPath());
                    return "\t- file differs (relative to " + projectDisplayName + "): (expected) " + expectedFile + " != (actual) " + actualFile;
                }
                case CLASSIFIER:

task verify {
    doLast {
        $resolveAndCheck
        throw failure
    }
}
"""
        }
    }

    private String checkComponentResultArtifacts(String componentResult, String type, def expectedFiles) {
        """
    def ${type}ArtifactResultFiles = []
    ${componentResult}.getArtifacts(${type.capitalize()}Artifact).each { artifactResult ->

        return model.classPath.collect { it.canonicalFile }
    }

    protected static void assertClassPathContains(List<File> classPath, File... expectedFiles) {
        assertThat(
            classPath.collect { it.name } as List<String>,
            hasItems(fileNameSetOf(expectedFiles))
        )
    }

    protected static void assertIncludes(List<File> classPath, File... files) {
        assertThat(