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"]
    }

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

${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()
        }
    }

        )
    }

    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

            }
            .collect { List<BuildWithSystemPropertyDefined> definitions, SystemPropertyAccess access ->
                new Spec(definitions, access)
            }
            .toSorted { it.toString() }
    }

    static class Spec {
        private final List<BuildWithSystemPropertyDefined> systemPropertyDefinitions
        private final SystemPropertyAccess systemPropertyAccess