import spock.lang.Specification

import java.util.regex.Pattern

import static org.gradle.util.Matchers.matchesRegexp

class MatchersTest extends Specification {

    def "matches regex"() {
        expect:
        matchesRegexp("foo.*").matches(match)

        and:
        !matchesRegexp(Pattern.compile("foo.*")).matches(noMatch)

        where:
        match     | noMatch
        "foo"     | "fo"

import org.gradle.test.fixtures.server.http.MavenHttpModule
import org.gradle.test.fixtures.server.http.MavenHttpRepository
import org.hamcrest.CoreMatchers

import static org.gradle.util.Matchers.matchesRegexp

@IntegrationTestTimeout(120)
class RecoverFromBrokenResolutionIntegrationTest extends AbstractHttpDependencyResolutionTest {

    MavenHttpRepository repo
    MavenHttpModule module

        failure.assertThatCause(matchesRegexp("Could not resolve all (dependencies|artifacts|files) for configuration '${Pattern.quote(configuration)}'."))
        this
    }

    DependencyResolutionFailure assertFailedDependencyRequiredBy(String dependency) {
        failure.assertThatCause(matchesRegexp("(?ms).*Required by:\\s+$dependency.*"))
        this
    }

        ScriptSource source = forFile(scriptFile);
        assertThat(source.getClassName(), matchesRegexp("build_[0-9a-z]+"));
    }

    @Test
    public void generatesClassNameFromFileNameByRemovingExtensionAndAddingHashOfJarURL() throws Exception {
        ScriptSource source = forUri(createJar());
        assertThat(source.getClassName(), matchesRegexp("build_[0-9a-z]+"));
    }

    @Test

        containsLine(result.getOutput(), "FINISH [Gradle Test Run :test] [Gradle Test Run :test] [FAILURE] [4]")

        containsLine(result.getOutput(), matchesRegexp("START \\[Gradle Test Executor \\d+\\] \\[Gradle Test Executor \\d+\\]"))
        containsLine(result.getOutput(), matchesRegexp("FINISH \\[Gradle Test Executor \\d+\\] \\[Gradle Test Executor \\d+\\] \\[FAILURE\\] \\[4\\]"))

import org.gradle.test.fixtures.keystore.TestKeyStore
import org.gradle.test.fixtures.server.http.AuthScheme
import org.junit.Rule

import static org.gradle.util.Matchers.containsText
import static org.gradle.util.Matchers.matchesRegexp

abstract class AbstractHttpsRepoResolveIntegrationTest extends AbstractHttpDependencyResolutionTest {
    @Rule TestResources resources = new TestResources(temporaryFolder)
    TestKeyStore keyStore

import java.io.StringReader;
import java.util.regex.Pattern;

import static org.hamcrest.CoreMatchers.equalTo;

public class Matchers {

    @Factory
    public static <T extends CharSequence> Matcher<T> matchesRegexp(final String pattern) {
        return new BaseMatcher<T>() {
            @Override
            public boolean matches(Object o) {

import org.gradle.process.ExecOperations
import spock.lang.Issue

import java.util.concurrent.atomic.AtomicInteger

import static org.gradle.util.Matchers.matchesRegexp
import static org.hamcrest.Matchers.containsString

class ArtifactTransformValuesInjectionIntegrationTest extends AbstractDependencyResolutionTest implements ArtifactTransformTestFixture, ValidationMessageChecker {

import java.util.stream.Stream

import static org.gradle.initialization.IGradlePropertiesLoader.ENV_PROJECT_PROPERTIES_PREFIX
import static org.gradle.util.Matchers.containsLine
import static org.gradle.util.Matchers.matchesRegexp

class ConfigurationCacheEncryptionIntegrationTest extends AbstractConfigurationCacheIntegrationTest {
    TestFile keyStoreDir
    String encryptionKeyText
    String encryptionKeyAsBase64

    def setup() {

                jvmArgs '-XX:UnknownArgument'
            }
        '''
    }

    void assertFatalTestExecutionError() {
        failure.assertThatCause(Matchers.matchesRegexp("Process 'Gradle Test Executor \\d+' finished with non-zero exit value \\d+"))
    }

    def withTestVerificationFailure() {
        file('src/test/java/example/UnitTestWithVerificationFailure.java').java '''