assertChecksumPublishedFor(moduleDir.file(name))
        }
    }

    void assertChecksumPublishedFor(TestFile testFile) {
        def sha1File = sha1File(testFile)
        sha1File.assertIsFile()
        assert HashCode.fromString(sha1File.text) == Hashing.sha1().hashFile(testFile)
    }

    void assertNotPublished() {
        ivyFile.assertDoesNotExist()
    }

                }
            }
"""
    }

    private void goodTests(TestFile root = testDirectory) {
        root.file("src/test/groovy/org/gradle/Class1.groovy") << "package org.gradle; class TestClass1 { @org.junit.Test void ok() { } }"
        withTests()
    }

    private void badTests(TestFile root = testDirectory) {

import org.gradle.test.fixtures.file.TestFile
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.junit.Rule
import spock.lang.Specification

class DefaultModuleRegistryTest extends Specification {
    @Rule
    final TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    TestFile runtimeDep
    TestFile externalRuntimeDep
    TestFile resourcesDir
    TestFile jarFile

import org.gradle.internal.logging.progress.ProgressLogger
import org.gradle.internal.logging.progress.ProgressLoggerFactory
import org.gradle.internal.time.Time
import org.gradle.test.fixtures.file.TestFile
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.gradle.tooling.GradleConnectionException
import org.gradle.tooling.events.FinishEvent
import org.gradle.tooling.events.StartEvent

            }
        """.stripIndent()
    }

    TestFile apply(TestFile dir) {
        def buildFile = dir.file("build.gradle")
        buildFile << """
            plugins {
                id("my.plugin")
            }
        """
        configuring(buildFile)
        return buildFile
    }

    TestFile configuring(TestFile buildFile) {
        buildFile << """

	require.NoError(t, err)
	defer os.RemoveAll(dir)

	testFile, err := os.CreateTemp(dir, "test-rotate-latest-log")
	require.NoError(t, err)
	defer testFile.Close()
	testContent := "test log content"
	_, err = testFile.Write([]byte(testContent))
	require.NoError(t, err)
	testFile.Close()

	testLog := testFile.Name()
	c := &containerLogManager{osInterface: container.RealOS{}}

            """
        }
    }

    def idea(TestFile build = buildA) {
        executer.inDirectory(build)
        succeeds(":idea")
    }

    def ipr(TestFile projectDir = buildA) {
        def iprFile = projectDir.file(projectDir.name + ".ipr")
        assert iprFile.exists()
        return IdeaFixtures.parseIpr(iprFile)
    }

    def iml(TestFile projectDir = buildA) {

        run 'unpackJar'

        then:
        executedAndNotSkipped ':jar', ':unpackJar'
    }

    private def createTar(String name, Closure cl) {
        TestFile tarRoot = file("${name}.root")
        tarRoot.deleteDir()
        TestFile tar = file(name)
        tar.delete()
        tarRoot.create(cl)
        tarRoot.tarTo(tar)
    }

    private def createFilesStructureForDupeTests() {

    IncrementalHelloWorldApp app
    String mainCompileTask
    String libraryCompileTask
    TestFile sourceFile
    TestFile headerFile
    TestFile commonHeaderFile
    List<TestFile> librarySourceFiles = []

    boolean languageBuildsOnMultiplePlatforms() {
        return true
    }

    abstract IncrementalHelloWorldApp getHelloWorldApp()

        toolingApi.daemons
    }

    TestFile getProjectDir() {
        temporaryFolder.testDirectory
    }

    @Override
    TestFile getBuildFileKts() {
        validateKotlinCompatibility()
        KotlinDslTestProjectInitiation.super.getBuildFileKts()
    }

    @Override
    TestFile getSettingsFileKts() {
        validateKotlinCompatibility()