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 {

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

        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(

}
        """
    }

    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,

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

        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)

        then:
        thrown(AssertionError)
    }

    def "successful lines contained in comparisons: #expectedLines vs #actualLines"() {
        expect:
        comparer.assertLinesContainedIn(expectedLines, actualLines)

        where:
        expectedLines           | actualLines
        ["a", "b", "c"]         | ["a", "b", "c"]
        ["a"]                   | ["a", "b"]