import spock.lang.Specification

class PrettyPrefixedLogHeaderFormatterTest extends Specification {

    def "formats header of failed operation that has status"() {
        setup:
        def formatter = new PrettyPrefixedLogHeaderFormatter()

        when:
        def formattedText = formatter.format(":test", "XYZ", true)

        then:
        formattedText.size() == 3

    def "add skips action if file already exists"() {
        setup:
        def file = temporaryFolder.createFile("fsbase/a/a");

        when:
        def fileInStore = uniquePathKeyFileStore.add("a/a", action)

        then:
        fileInStore.file == file
        0 * action.execute(_)
    }

    def "move returns existing file if it already exists"() {
        setup:
        def source = temporaryFolder.createFile("some-file")

		t.Errorf("Got unexpected path: %s", volumePath)
	}

	err = mounter.SetUp(volume.MounterArgs{})
	if err != nil {
		t.Errorf("Failed to setup volume: %v", err)
	}
	if _, err := os.Stat(volumePath); err != nil {
		if os.IsNotExist(err) {
			t.Errorf("SetUp() failed, volume path not created: %s", volumePath)
		} else {
			t.Errorf("SetUp() failed: %v", err)
		}
	}

    enum class Type {
      Handshake,
      Plaintext,
      Encrypted,
      Setup,
      Unknown,
    }

    val type: Type
      get() =
        when {
          message == "adding as trusted certificates" -> Type.Setup
          message == "Raw read" || message == "Raw write" -> Type.Encrypted

    }

    def "can configure in gradle.properties file"() {
        setup:
        file('gradle.properties') << 'org.gradle.logging.stacktrace=full'

        when:
        fails()

        then:
        assertCauseWithStacktrace('show stacktrace was ALWAYS_FULL')
    }

    def "configuration is case-insensitive"() {
        setup:
        file('gradle.properties') << 'org.gradle.logging.stacktrace=FuLl'

import static org.gradle.integtests.tooling.fixture.TextUtil.normaliseLineSeparators

@ToolingApiVersion('>=7.6')
@TargetGradleVersion(">=7.6")
class TestLauncherTestSpecCrossVersionSpec extends TestLauncherSpec {

    def setup() {
        withFailingTest() // ensures that withTestsFor statements are not ignored
    }

    @TargetGradleVersion('>=3.0 <7.6')
    def "older Gradle versions ignore withTestsFor calls"() {
        when:

    def "Java project has default output location"() {
        setup:
        buildFile << "apply plugin: 'java'"
        EclipseProject project = loadToolingModel(EclipseProject)

        when:
        EclipseOutputLocation output = project.getOutputLocation()

        then:
        output.path == 'bin'
    }

    def "Custom output location defined in dsl"() {
        setup:
        buildFile <<
        """apply plugin: 'java'

! go test -v -race main_panic/testmain_parallel_sub_panic_test.go
! stdout 'DATA RACE'
-- main_panic/testmain_parallel_sub_panic_test.go --
package testmain_parallel_sub_panic_test

import "testing"

func setup()    { println("setup()") }
func teardown() { println("teardown()") }
func TestA(t *testing.T) {
	t.Run("1", func(t *testing.T) {
		t.Run("1", func(t *testing.T) {
			t.Parallel()
			panic("A/1/1 panics")
		})

import org.gradle.tooling.TestLauncher

import java.util.regex.Pattern

@TargetGradleVersion(">=7.6")
@ToolingApiVersion(">=7.6")
class TestLauncherTaskExecutionCrossVersionSpec extends ToolingApiSpecification {

    def setup() {
        file('build.gradle') << """
            plugins {
                id 'java-library'
            }

            ${mavenCentralRepository()}

            dependencies {

        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Configure JDK
        uses: actions/setup-java@v4
        with:
          distribution: 'zulu'
          java-version: 17

      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v3

      - name: Run Container Tests