}
}

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

        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"]

        protected final List<String> expectedLines;
        protected final List<String> actualLines;

        public AbstractLineListComparisonFailure(List<String> expectedLines, List<String> actualLines) {
            this.expectedLines = expectedLines;
            this.actualLines = actualLines;
        }

        @Override

    public void assertLinesContainedIn(List<String> expectedLines, List<String> actualLines) throws LineSearchFailures.AbstractLineListComparisonFailure {
        assert !expectedLines.isEmpty() : "there must be expected text";
        assert !actualLines.isEmpty() : "there must be output text";

        if (actualLines.size() < expectedLines.size()) {
            LineSearchFailures.insufficientSize(expectedLines, actualLines);
        }

        Preconditions.checkArgument(isPossibleMatchIndex(expectedLines, actualLines, matchBeginsActualIdx), "match would extend beyond actual lines");

        this.expectedLines = expectedLines;
        this.actualLines = actualLines;
        this.matchBeginsActualIdx = matchBeginsActualIdx;