* See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.testkit.runner.internal.feature;

import org.gradle.internal.deprecation.DeprecationLogger;
import org.gradle.testkit.runner.UnsupportedFeatureException;
import org.gradle.util.GradleVersion;

package org.myorg

import org.gradle.testkit.runner.GradleRunner
import spock.lang.Specification
import spock.lang.TempDir

import static org.gradle.testkit.runner.TaskOutcome.SUCCESS

class UrlVerifierPluginFunctionalTest extends Specification {
    @TempDir File testProjectDir
    File buildFile

    def setup() {
        buildFile = new File(testProjectDir, 'build.gradle')
        buildFile << """
            plugins {

    private static final int CONCURRENT_BUILDS_PROJECT_COUNT = 4
    private static final int CONCURRENT_TASKS_PROJECT_COUNT = 4

    def "Gradle API and TestKit dependency can be resolved and used by concurrent Gradle builds"() {
        given:
        setupProjects(CONCURRENT_BUILDS_PROJECT_COUNT) { projectDirName, buildFile ->
            buildFile << testablePluginProject()

import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.IntegTestPreconditions
import org.gradle.testkit.runner.fixtures.NoDebug
import org.gradle.testkit.runner.fixtures.NonCrossVersion
import org.gradle.tooling.GradleConnectionException
import org.gradle.util.GradleVersion
import spock.lang.Issue

@NonCrossVersion

import org.gradle.test.fixtures.AbstractProjectBuilderSpec
import org.gradle.util.TestUtil

class JavadocTest extends AbstractProjectBuilderSpec {

    def testDir = temporaryFolder.getTestDirectory()
    def destDir = new File(testDir, "dest")
    def srcDir = new File(testDir, "srcdir")
    def configurationMock = TestFiles.fixed(new File("classpath"))
    def tool = Mock(JavadocToolAdapter)

    Javadoc task

    def setup() {

    TestFile testFile
    TestFile testFileLock
    TestFile testDir
    TestFile testDirLock

    List<Closeable> openedLocks = []

    def setup() {
        testFile = tmpDir.createFile("state.bin")
        testFileLock = tmpDir.file(testFile.name + ".lock")
        testDir = tmpDir.createDir("lockable-dir")
        testDirLock = tmpDir.file("${testDir.name}/${testDir.name}.lock")

        metaDataProvider.processIdentifier >> '123'

        }
        if (isSet(mode, 01)) {
            result.add(OTHERS_EXECUTE);
        }
        return result;
    }

    private static boolean isSet(int mode, int testbit) {
        return (mode & testbit) == testbit;
    }

    public static int convertToInt(Set<PosixFilePermission> permissions) {
        int result = 0;
        if (permissions.contains(OWNER_READ)) {
            result = result | 0400;

${fileComment.multilineComment}${packageDecl.javaStatement}
import java.io.File;
import java.io.IOException;
import java.io.Writer;
import java.io.FileWriter;
import java.nio.file.Files;
import org.gradle.testkit.runner.GradleRunner;
import org.gradle.testkit.runner.BuildResult;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import static org.junit.jupiter.api.Assertions.*;

/**

    }

    def "arguments include GCC output flag and output file name"() {
        given:
        def compiler = getCompiler()
        def testDir = tmpDirProvider.testDirectory
        def outputFile = testDir.file("output.ext")

        when:
        def args = compiler.getOutputArgs(Stub(NativeCompileSpec), outputFile)

        then:

import spock.lang.Specification

@UsesNativeServices
class WrapperPluginSpec extends Specification {
    @Rule
    public final TestNameTestDirectoryProvider testDir = new TestNameTestDirectoryProvider(getClass())
    def project = TestUtil.createRootProject(testDir.testDirectory)

    def "adds 'wrapper' task"() {
        when:
        project.pluginManager.apply WrapperPlugin

        then: