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

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

            }
            .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

        return Files.find(file.toPath(), 99, { path, attributes -> attributes.isRegularFile() })
            .collect { file.toPath().relativize(it).toString().replace("\\", "/") }
            .toSorted()
    }

    private boolean hasOnlyDirectories(File file) {
        try (Stream<Path> stream = Files.walk(file.toPath())) {
            return stream.allMatch { Files.isDirectory(it) }
        }
    }