}
    }

    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 buildTreePath = modelExpectation.path
            if (modelExpectation.modelNames != null) {
                def projectModelNames =  projectModels[buildTreePath].modelName.toSorted()
                assert projectModelNames == modelExpectation.modelNames.toSorted()
            }
        }
    }

    private void assertHasWarningThatIncubatingFeatureUsed() {

        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) {

${modules.toSorted().collect {"$it=$lockFileId"}.join('\n')}
empty=
""".denormalize()
        } else {
            lockDir.file("${lockFileId}.lockfile") << """${LockFileReaderWriter.LOCKFILE_HEADER_LIST.join('\n')}
${modules.toSorted().join('\n')}
""".denormalize()
        }
    }

            }
            task resolvedFiles {
                dependsOn 'dependencies'
                def files = configurations.conf

                doLast {
                    println "resolved files=" + files*.name.toSorted()
                }
            }
        """
        resolve = new ResolveTestFixture(buildFile)
        resolve.addDefaultVariantDerivationStrategy()
    }

    //publishes and declares the dependencies

        )
    }

    static boolean equalIgnoringOrder(Object actual, Collection<?> expected) {
        List<?> actualSorted = (actual as List).toSorted()
        List<?> expectedSorted = (expected as List).toSorted()
        return actualSorted == expectedSorted
    }

    boolean vfsHasSnapshotsAt(File location) {
        return virtualFileSystem.root.rootSnapshotsUnder(location.absolutePath)

            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