def expectedFiles = provider {
        [file('${normaliseFileSeparators(shared10.artifactFile.path)}'), file('${normaliseFileSeparators(compileOnlyModule.artifactFile.path)}')] as Set
    }
    doLast {
        assert compileOnlyClasspath.files == expectedFiles.get()
    }
}

task checkCompileClasspath{
    def compileClasspath = configurations.compileClasspath
    def expectedFiles = provider {

        return model.classPath.collect { it.canonicalFile }
    }

    protected static void assertClassPathContains(List<File> classPath, File... expectedFiles) {
        assertThat(
            classPath.collect { it.name } as List<String>,
            hasItems(fileNameSetOf(expectedFiles))
        )
    }

    protected static void assertIncludes(List<File> classPath, File... files) {
        assertThat(

        when:
        def expectedFile1 = tmpDir.createDir("foo/bar")
        def expectedFile2 = tmpDir.createDir("foo/123")
        buildOptions.installationsFromPaths >> [expectedFile1.absolutePath, expectedFile2.absolutePath]
        def directories = supplier.get()

        then:
        directories.size() == 2
        directories*.location.containsAll(expectedFile1, expectedFile2)

        then:
        thrown(AssertionError)
    }

    def "successful lines contained in comparisons: #expectedLines vs #actualLines"() {
        expect:
        comparer.assertLinesContainedIn(expectedLines, actualLines)

        where:
        expectedLines           | actualLines
        ["a", "b", "c"]         | ["a", "b", "c"]
        ["a"]                   | ["a", "b"]

        protected final List<String> expectedLines;
        protected final List<String> actualLines;

        public AbstractLineListComparisonFailure(List<String> expectedLines, List<String> actualLines) {
            this.expectedLines = expectedLines;
            this.actualLines = actualLines;
        }

        @Override

    public void assertLinesContainedIn(List<String> expectedLines, List<String> actualLines) throws LineSearchFailures.AbstractLineListComparisonFailure {
        assert !expectedLines.isEmpty() : "there must be expected text";
        assert !actualLines.isEmpty() : "there must be output text";

        if (actualLines.size() < expectedLines.size()) {
            LineSearchFailures.insufficientSize(expectedLines, actualLines);
        }

        Preconditions.checkArgument(isPossibleMatchIndex(expectedLines, actualLines, matchBeginsActualIdx), "match would extend beyond actual lines");

        this.expectedLines = expectedLines;
        this.actualLines = actualLines;
        this.matchBeginsActualIdx = matchBeginsActualIdx;

        List expectedLines = expected.readLines().findAll { !it.isEmpty() }
        assertOutputLinesMatch(expectedLines, actualLines, ignoreExtraLines, actual)
    }

    protected void assertOutputLinesMatch(List<String> expectedLines, List<String> actualLines, boolean ignoreExtraLines, String actual) {
        int pos = 0
        for (; pos < actualLines.size() && pos < expectedLines.size(); pos++) {

    protected void assertOutputLinesMatch(List<String> expectedLines, List<String> actualLines, boolean ignoreExtraLines, String actual) {
        List<String> unmatchedLines = new ArrayList<String>(actualLines)
        expectedLines.removeAll('')
        unmatchedLines.removeAll('')

        expectedLines.each { expectedLine ->
            def matchedLine = unmatchedLines.find { actualLine ->

                doLast {
                    assert files*.name == ["foo-1.0.jar", "${expectedFile}"]
                }
            }
        """

        expect:
        succeeds("resolve")

        where:
        artifactDeclaration | expectedFile
        ""                  | "transitive-1.0-cls.jar"
        '"extension": "",'  | "transitive-1.0-cls"
    }