1 * selectedChild.getSnapshot(searchedPath.pathFromChild(selectedChildPath), CASE_SENSITIVE) >> Optional.ofNullable(foundSnapshot)
    }

    def getDescendantNodeOfSelectedChild(@Nullable FileSystemNode foundNode) {
        1 * selectedChild.getNode(searchedPath.pathFromChild(selectedChildPath), CASE_SENSITIVE) >> Optional.ofNullable(foundNode)
    }

        }
    }

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

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

                  "*"
                ],
                "routes": [
                  {
                    "match": {
                      "path": "/productpage",
                      "case_sensitive": true
                    },
                    "route": {
                      "cluster": "outbound|9080||productpage.default.svc.cluster.local",
                      "timeout": "0s",

 * limitations under the License.
 */

package org.gradle.internal.snapshot

import spock.lang.Specification

import static org.gradle.internal.snapshot.CaseSensitivity.CASE_SENSITIVE

class VfsRelativePathTest extends Specification {

    def "convert absolute path '#absolutePath' to relative path '#relativePath'"() {
        expect:

            this.indicatorPattern = Pattern.compile(indicatorString, Pattern.CASE_INSENSITIVE);
            this.displayName = displayName;
        }

        KnownJvmVendor(String indicatorString, String pattern, String displayName) {
            this.indicatorString = indicatorString;
            this.indicatorPattern = Pattern.compile(pattern, Pattern.CASE_INSENSITIVE);
            this.displayName = displayName;
        }

            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());

    }

    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']))

        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

@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()
    }

		<property name="childUrlRuleMap">htmlUrlRuleMap</property>
		<!--
		<property name="invalidUrlPattern">@java.util.regex.Pattern@compile("^\\s*javascript:|^\\s*mailto:|^\\s*irc:|^\\s*skype:|^\\s*callto:",@java.util.regex.Pattern@CASE_INSENSITIVE)</property>
		 -->
		<property name="convertUrlMap">
			{"feed:" : "http:"}
		</property>
		<!-- segment -->
		<postConstruct name="addFieldRule">
			<arg>"title"</arg>
			<arg>"//TITLE"</arg>