@Internal
                List<String> expectedFiles = []

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

            task resolveSources(type: Resolve) {

            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')

}
        """
    }

    void assertHasExpectedContents(TestFile actualFile, String expectedFileName) {
        actualFile.assertExists()
        TestFile expectedFile = testDirectory.file("expectedFiles/$expectedFileName").assertIsFile()
        String expectedXml = expectedFile.text
        String actualXml = getActualXml(actualFile)
        Diff diff = new Diff(expectedXml, actualXml)

	}
}

func TestCreateCertificateFilesMethods(t *testing.T) {

	var tests = []struct {
		createFunc    func(cfg *kubeadmapi.InitConfiguration) error
		expectedFiles []string
		externalEtcd  bool
	}{
		{
			createFunc: CreatePKIAssets,
			expectedFiles: []string{
				kubeadmconstants.CACertName, kubeadmconstants.CAKeyName,
				kubeadmconstants.APIServerCertName, kubeadmconstants.APIServerKeyName,

         'img': ['gradle-logo.png']].each { dir, files ->
            def resourceDir = new File(currentReportDir, dir)
            def resources = resourceDir.list() as Set<String>
            def expectedFiles = files as Set<String>
            assert expectedFiles == resources
        }
    }

    def "can add different sections"() {
        given:
        renderer.startNewSection("First section")

        when:
        generateReport()

        then:
        executedAndNotSkipped(":publishIvyJavaPublicationToIvyRepository")
        expectedFiles(this).forEach { it.assertExists() }
        unexpectedFiles(this).forEach { it.assertDoesNotExist() }

        where:
        layout     | declaration | expectedFiles                               | unexpectedFiles
        "standard" | ""          | this.&expectedFilesIvyPublishStandardLayout | { [] }

}

func TestCreateKubeconfigFilesAndWrappers(t *testing.T) {
	var tests = []struct {
		name                     string
		createKubeConfigFunction func(outDir string, cfg *kubeadmapi.InitConfiguration) error
		expectedFiles            []string
		expectedError            bool
	}{
		{ // Test createKubeConfigFiles fails for unknown kubeconfig is requested
			name: "createKubeConfigFiles",

    }

    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, '/')

        }

        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:

		if len(got) != len(tc.ExpectedRules) {
			t.Fatalf("Expected matching number of actionable rules: `%v`, got: `%v`", tc.ExpectedRules, got)
		}
		for i := range got {
			if got[i].Destination.ARN != tc.ExpectedRules[i].Destination.ARN || got[i].Priority != tc.ExpectedRules[i].Priority {
				t.Fatalf("Expected order of filtered rules to be identical: `%v`, got: `%v`", tc.ExpectedRules, got)
			}
		}
	}