buildScript(classes.buildScript())

        when:
        succeeds scaladoc
        then:
        executedAndNotSkipped scaladoc

        when:
        succeeds scaladoc
        then:
        skipped scaladoc
        newScalaVersion != this.classes.scalaVersion

        when:
        this.classes.scalaVersion = newScalaVersion
        buildScript(this.classes.buildScript())
        succeeds scaladoc
        then:

    public void skipBytes(long count) throws EOFException, IOException {
        long remaining = count;
        while (remaining > 0) {
            long skipped = maybeSkip(remaining);
            if (skipped <= 0) {
                break;
            }
            remaining -= skipped;
        }
        if (remaining > 0) {
            throw new EOFException();
        }
    }

    @Override

            inDirectory(newLocation)
        }
        withBuildCache().run upstreamCompileTasks

        then:
        skipped upstreamCompileTasks

        when:
        run compileTask(buildType), installTask(buildType)

        then:
        skipped upstreamCompileTasks
        executedAndNotSkipped compileTask(buildType)

        executedAndNotSkipped(":compileJava", ":compileTestJava", ":test")
        skipped(":processResources")

        when:
        testFile.text = "class TestThing extends Thing { static public int FLAG = 1; }"

        then:
        buildTriggeredAndSucceeded()
        executedAndNotSkipped(":compileTestJava", ":test")
        skipped(":processResources", ":compileJava")

        when:

        when:
        run "copy"

        then:
        skipped(':copy')

        when:
        run "copy", "-Dcase-sensitive"

        then:
        executedAndNotSkipped(':copy')

        when:
        run "copy", "-Dcase-sensitive"

        then:
        skipped(':copy')
    }

    @ToBeImplemented

        when:
        succeeds "clean"
        then:
        reportFile.assertDoesNotExist()

        when:
        withBuildCache().run "jacocoTestReport", "jacocoTestCoverageVerification"
        then:
        skipped ":test", ":jacocoTestReport", ":jacocoTestCoverageVerification"
        reportFile.assertContentsHaveNotChangedSince(snapshot)
    }

    def "jacoco file results are not cached when sharing output with another task"() {

                    case SUCCESS:
                        return Collections.singleton(success(classId, execution.getId()));
                    case SKIPPED:
                        return Collections.singleton(skipped(classId, execution.getId()));
                    case FAILURE:
                        return failures(classId, execution, allFailed

     * Asserts that the given tests have the given outcome for the given test class.
     */
    default TestClassExecutionResult assertTestOutcomes(TestOutcome status, String... testNames) {
        if (status == TestOutcome.SKIPPED) {
            return assertTestsSkipped(testNames);
        }
        for (String testName : testNames) {
            switch (status) {
                case PASSED:
                    assertTestPassed(testName);

            def pluginsWithProjectPath = result.tasks
                .findAll {
                    !(it.outcome in [
                        TaskOutcome.NO_SOURCE,
                        TaskOutcome.SKIPPED
                    ]) && it.path.contains(taskPattern) && !it.path.startsWith(':plugins:') // ignore plugins project from previous version, it doesn't exist anymore (TODO: remove this check)
                }

        // Work around some bugs in Input.skip()
        int remaining = input.limit() - input.position();
        if (remaining == 0) {
            long skipped = inputStream.skip(count);
            if (skipped > 0) {
                extraSkipped += skipped;
            }
            return skipped;
        } else if (count <= remaining) {
            input.setPosition(input.position() + (int) count);
            return count;
        } else {