}

// dedupEnvCase is dedupEnv with a case option for testing.
// If caseInsensitive is true, the case of keys is ignored.
// If nulOK is false, items containing NUL characters are allowed.
func dedupEnvCase(caseInsensitive, nulOK bool, env []string) ([]string, error) {
	// Construct the output in reverse order, to preserve the
	// last occurrence of each key.

    public static <V, T extends Collection<? super V>> T addToCollection(T dest, Iterable<? extends V>... srcs) {
        return addToCollection(dest, false, srcs);
    }

    public static Comparator<String> caseInsensitive() {
        return new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                int diff = o1.compareToIgnoreCase(o2);
                if (diff != 0) {

        CASE_SENSITIVE(true),
        CASE_INSENSITIVE(false);

        CaseSensitivity(boolean caseSensitive) {
            this.caseSensitive = caseSensitive;
        }

        public static CaseSensitivity forCaseSensitive(boolean caseSensitive) {
            return caseSensitive
                ? CASE_SENSITIVE
                : CASE_INSENSITIVE;
        }

        private final boolean caseSensitive;

import com.google.common.annotations.VisibleForTesting;

import java.io.File;
import java.util.Comparator;

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

/**
 * Methods for dealing with paths on the file system.
 *
 * There are methods for checking equality and for comparing two paths.

        compareChars(char2, char1) == Character.compare(char2, char1)
        !equalChars(char1, char2, CASE_SENSITIVE)
        equalChars(char1, char2, CASE_INSENSITIVE) == (caseInsensitiveResult == 0)
        !equalChars(char2, char1, CASE_SENSITIVE)
        equalChars(char2, char1, CASE_INSENSITIVE) == (caseInsensitiveResult == 0)

        where:
        left | right | result
        'a'  | 'A'   | 32

import spock.lang.Specification

class HasPrefixAndSuffixPatternStepTest extends Specification {
    static final boolean CASE_SENSITIVE = true;
    static final boolean CASE_INSENSITIVE = false;

    def "matches name case sensitive"() {
        def step = new HasPrefixAndSuffixPatternStep("pre", "suf", CASE_SENSITIVE)

        expect:
        step.matches("pre-suf")
        step.matches("presufsuf")
        step.matches("presuf")

                VfsRelativePath.of(searchedChild).compareToFirstSegment(child, CASE_SENSITIVE)
            }
            assert foundIndex == i
        }
    }

    def "children #children are sorted the same with path sensitive and path insensitive compare"() {
        def caseInsensitiveSorted = children.toSorted(getPathComparator(CaseSensitivity.CASE_INSENSITIVE))

 * since it seems that the methods can be better inlined by the JIT compiler if they are static.
 */
public enum CaseSensitivity {
    CASE_SENSITIVE,
    CASE_INSENSITIVE

    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 + "}";
    }

import org.gradle.tooling.internal.provider.continuous.ContinuousBuildActionExecutor;

import java.util.List;

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

public class LauncherServices extends AbstractGradleModuleServices {
    @Override
    public void registerGlobalServices(ServiceRegistration registration) {