}
    }

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

        where:
        children << CHILDREN_LISTS
    }

        when:
        def directories = supplier.get()

        then:
        directories.size() == 2
        directories*.location.toSorted() == [
            candidates.file("11.0.6.hs-adpt"),
            candidates.file("14")
        ]
        directories*.source.unique() == ["Common Linux Locations"]
    }

        []                           | "baa"
        ["b"]                        | "a"
        ["a"]                        | "b"
        ["a"]                        | "a"

        sortedChildren = children.toSorted()
        expectedResult = Collections.binarySearch(sortedChildren, searchedChild)
    }

                ant.defaultexcludes default: true
            }
        """
        List<String> defaultExcludesFromSettings = (DEFAULT_EXCLUDES  + ['**/' + EXCLUDED_FILE_NAME]).toSorted()
        List<String> defaultExcludesInTask = DEFAULT_EXCLUDES.toSorted()

        when:
        fails "copyTask"

        then:

        def lines = new ArrayList(LockFileReaderWriter.LOCKFILE_HEADER_LIST)
        if (modules.isEmpty()) {
            lines.add("empty=$configuration")
        } else {
            lines.addAll modules.toSorted().collect({ "$it=$configuration".toString() })
            lines.add("empty=")
        }
        lockFile.writelns(lines)
    }

    private void createLegacyLockfile(String configurationName, List<String> modules) {

            println "> Tasks in surplus: " + (result.tasks.findAll { !outcomesWithMatchingTasks.keySet().contains(it.path) })
            println "> Updated definitions:"
            result.tasks
                .toSorted { a, b -> a.path <=> b.path }
                .forEach { task ->
                    println "'${task.path}': ${task.outcome},"
                }
        }

        boolean allOutcomesMatched = true

        ["Bad/mine", "c/other", "aB/second"],
        ["Bad/mine", "c/other", "AB/second"],
        ["Bad/mine", "cA/other", "AB/second"],
        ["c", "b/something", "a/very/long/suffix"]
    ]*.toSorted(getPathComparator(CASE_SENSITIVE))

    static final List<CaseSensitivityTestSpec> SAME_OR_CHILD = CHILDREN_LISTS.collectMany { children ->
        children.collectMany { child ->