package org.gradle.testing.junit.junit4

import org.gradle.integtests.fixtures.AbstractSampleIntegrationTest
import org.gradle.integtests.fixtures.DefaultTestExecutionResult

import static org.hamcrest.CoreMatchers.startsWith

class JUnit4CategoriesNotSupportedIntegrationTest extends AbstractSampleIntegrationTest {

    def "test task fails if categories not supported"() {
        given:

        when:
        withConnection {
            it.action(new ActionShouldNotBeCalled()).run()
        }

        then:
        BuildException e = thrown()
        e.message.startsWith('Could not run build action using')
        e.cause.message.contains('A problem occurred evaluating root project')

        and:
        failure.assertHasDescription('A problem occurred evaluating root project')

        executionMetadata.tempSampleProjectDir.name.startsWith('building-scala')
            ? normalizeScalaOutput(output)
            : output
    }

    private String normalizeScalaOutput(String output) {
        PATTERN.matcher(output)
            .replaceAll("")
            .with {
                // remove starting empty line
                it.startsWith('\n')
                    ? it.substring(1)

            }
        }
        if (!builder.displayName.startsWith("Maven ")) {
            throw new IllegalArgumentException("Maven invocation display name must start with 'Maven '")
        }
    }

    @Override
    protected void finalizeGradleSpec(GradleBuildExperimentSpec.GradleBuilder builder) {
        super.finalizeGradleSpec(builder)
        if (!builder.displayName.startsWith("Gradle ")) {

            }
            while ((urlQueue = urlQueueService.poll(sessionId2)) != null) {
                assertTrue(urlQueue.getUrl() + "=>" + url2, urlQueue.getUrl().startsWith(url2));
            }

            dataService.iterate(sessionId1, accessResult -> assertTrue(accessResult.getUrl().startsWith(url1)));

        return methodName.startsWith(prefix) && methodName.length() > prefix.length() && Character.isUpperCase(methodName.charAt(prefix.length()));
    }

    private static String getPropertyName(String methodName) {
        if (methodName.startsWith("get")) {
            return getPropertyName(methodName, "get");
        } else if (methodName.startsWith("is")) {
            return getPropertyName(methodName, "is");

        Iterator<File> iterator = apiClasspath.iterator();
        while (iterator.hasNext()) {
            String name = iterator.next().getName();
            if (name.startsWith("kotlin-") || name.startsWith("gradle-kotlin-")) {
                iterator.remove();
            }
        }
    }

    private List<File> kotlinImplFrom(Collection<File> classPath) {

                    } else if (line.startsWith(promptLiteralStart)) {
                        saveBuffer();
                        const value = line.replace(promptLiteralStart, "").trimEnd();
                        useLines.push({
                            type: "input",
                            value: value
                        });
                    } else if (line.startsWith("// ")) {
                        saveBuffer();

                assertTrue(urlQueue.getUrl().startsWith(url1));
            }
            while ((urlQueue = urlQueueService.poll(sessionId2)) != null) {
                assertTrue(urlQueue.getUrl().startsWith(url2));
            }

            dataService.iterate(sessionId1, accessResult -> {
                assertTrue(accessResult.getUrl().startsWith(url1));

                        || descriptor.displayName.startsWith('Execute unit of work')
                        || descriptor.displayName.startsWith('Execute transform')
                        || descriptor.displayName.startsWith('Executing ')
                        || descriptor.displayName.startsWith('Execute container callback action')
                        || descriptor.displayName.startsWith('Resolving ')