this.excludes = null;
        return exclude(excludes);
    }


    public boolean isCaseSensitive() {
        return caseSensitive;
    }

    public void setCaseSensitive(boolean caseSensitive) {
        this.caseSensitive = caseSensitive;
    }

    /*
    This can't be called just include, because it has the same erasure as include(Iterable<String>).
     */

        }
    }

    private void initializeCaseSensitive() {
        if (caseSensitive == null) {

            String content = generateUniqueContent();
            File file = null;
            try {
                checkJavaIoTmpDirExists();
                file = createFile(content);
                caseSensitive = probeCaseSensitive(file, content);
            } catch (IOException e) {

        when:
        spec.caseSensitive = false
        spec.includeEmptyDirs = false
        spec.duplicatesStrategy = DuplicatesStrategy.EXCLUDE
        setter.call(spec, objectFactory)
        spec.filteringCharset = 'UTF8'

        then:
        !spec.caseSensitive
        !spec.includeEmptyDirs
        spec.duplicatesStrategy == DuplicatesStrategy.EXCLUDE

    }

    def patternSetsAreEqualWhenAllPropertiesAreEqual() {
        expect:
        strictlyEquals(new PatternSet(), new PatternSet())
        strictlyEquals(new PatternSet(caseSensitive: false), new PatternSet(caseSensitive: false))
        strictlyEquals(new PatternSet(includes: ['i']), new PatternSet(includes: ['i']))
        strictlyEquals(new PatternSet(excludes: ['e']), new PatternSet(excludes: ['e']))

    private static final String ESCAPE_CHARS = "\\[]^-&.{}()$+|<=!";

    private final Pattern pattern;

    public RegExpPatternStep(String pattern, boolean caseSensitive) {
        this.pattern = Pattern.compile(getRegExPattern(pattern), caseSensitive?0:Pattern.CASE_INSENSITIVE);
    }

    @Override
    public String toString() {
        return "{regexp: " + pattern + "}";
    }

            if (envVars == null) {
                Properties tmp = new Properties();
                boolean caseSensitive = !Os.IS_WINDOWS;
                for (Map.Entry<String, String> entry : System.getenv().entrySet()) {
                    String key = "env."
                            + (caseSensitive ? entry.getKey() : entry.getKey().toUpperCase(Locale.ENGLISH));
                    tmp.setProperty(key, entry.getValue());

            ? lengthCompare
            : accumulatedValue;
    }

    private static int computeCombinedCompare(int previousCombinedValue, char charInPath1, char charInPath2, boolean caseSensitive) {
        if (!caseSensitive) {
            return 0;
        }
        return previousCombinedValue == 0
            ? compareChars(charInPath1, charInPath2)
            : previousCombinedValue;
    }

@Requires(UnitTestPreconditions.MacOs)
class MacOsFileSystemTest extends Specification {
    def fs = NativeServicesTestFixture.instance.get(FileSystem)

    def "is not case sensitive"() {
        expect:
        !fs.caseSensitive
    }

    def "can create symbolic link"() {
        expect:
        fs.canCreateSymbolicLink()
    }

            </tr>
            <tr>
                <td>source</td>
                <td><literal>[]</literal></td>
            </tr>
            <tr>
                <td>caseSensitive</td>
                <td><literal>true</literal></td>
            </tr>
            <tr>
                <td>dirPermissions</td>
                <td><literal>null</literal></td>
            </tr>
            <tr>

@Requires(UnitTestPreconditions.Linux)
class LinuxFileSystemTest extends Specification {
    def fs = NativeServicesTestFixture.instance.get(FileSystem)

    def "is case sensitive"() {
        expect:
        fs.caseSensitive
    }

    def "can create symbolic link"() {
        expect:
        fs.canCreateSymbolicLink()
    }