logger.debug("pattern1: {}, pattern2: {}", pattern1Str, pattern2Str);
        }
        if (pattern1Str != null) {
            pattern1 = Pattern.compile(pattern1Str);
            pattern2 = Pattern.compile(pattern2Str);
        }
    }

    @Override
    public TokenStream create(final TokenStream tokenStream) {
        return new PatternConcatenationFilter(tokenStream, pattern1, pattern2);
    }

        0 * _
    }

    def 'overlapping patterns filter out parts matching more than one pattern'() {
        def resource1 = Mock(ExternalResource)

        when:
        def pattern1 = pattern("/[organisation]/[module]/[revision]/ivy-[revision].xml")
        def pattern2 = pattern("/[organisation]/[module]/ivy-[revision].xml")
        lister.listVersions(module, artifact, [pattern1, pattern2], result)
        def versions = result.versions

    }

    def "builds union of versions"() {
        LocallyAvailableExternalResource resource1 = Mock()
        LocallyAvailableExternalResource resource2 = Mock()
        def pattern1 = pattern("prefix1/" + MavenPattern.M2_PATTERN)
        def pattern2 = pattern("prefix2/" + MavenPattern.M2_PATTERN)
        def location1 = new ExternalResourceName('prefix1/org/acme/testproject/maven-metadata.xml')

        ['org.gradle.Foo$1$2.test']       | "org.gradle.Foo"     | true
    }

    def 'can use multiple patterns'() {
        expect:
        matcher(pattern1, [], pattern2).mayIncludeClass(fullQualifiedName) == maybeMatch

        where:
        pattern1                | pattern2                        | fullQualifiedName     | maybeMatch

package org.gradle.api.tasks.util

import spock.lang.Specification

abstract class AbstractTestForPatternSet extends Specification {
    static final String TEST_PATTERN_1 = 'pattern1'
    static final String TEST_PATTERN_2 = 'pattern2'
    static final String TEST_PATTERN_3 = 'pattern3'

    abstract PatternFilterable getPatternSet()

    def testDefaultValues() {
        expect:
        patternSet.includes.empty

import org.gradle.util.internal.WrapUtil

class ScalaCompileTest extends AbstractConventionTaskTest {
    public static final String TEST_PATTERN_1 = "pattern1"
    public static final String TEST_PATTERN_2 = "pattern2"
    public static final String TEST_PATTERN_3 = "pattern3"

    protected File srcDir
    protected File destDir
    protected File depCacheDir

    private ScalaCompile scalaCompile

import static org.gradle.util.internal.WrapUtil.toSet

class TestTest extends AbstractConventionTaskTest {
    static final String TEST_PATTERN_1 = "pattern1"
    static final String TEST_PATTERN_2 = "pattern2"
    static final String TEST_PATTERN_3 = "pattern3"

    private File classesDir
    private File resultsDir
    private File binResultsDir
    private File reportDir

			significantly more expensive.
		Sets -cover.
	-coverpkg pattern1,pattern2,pattern3
		For a build that targets package 'main' (e.g. building a Go
		executable), apply coverage analysis to each package matching
		the patterns. The default is to apply coverage analysis to
		packages in the main Go module. See 'go help packages' for a
		description of package patterns.  Sets -cover.
	-v
		print the names of packages as they are compiled.

// than the other.
//
//	Precedence is defined by two rules:
//	1. Patterns with a host win over patterns without a host.
//	2. Patterns whose method and path is more specific win. One pattern is more
//	   specific than another if the second matches all the (method, path) pairs
//	   of the first and more.
//
// If rule 1 doesn't apply, then two patterns conflict if their relationship

//			significantly more expensive.
//		Sets -cover.
//	-coverpkg pattern1,pattern2,pattern3
//		For a build that targets package 'main' (e.g. building a Go
//		executable), apply coverage analysis to each package matching
//		the patterns. The default is to apply coverage analysis to
//		packages in the main Go module. See 'go help packages' for a
//		description of package patterns.  Sets -cover.
//	-v