when:
        rootLogger.level = Level.OFF
        loggingManager.levelInternal = LogLevel.WARN

        then:
        rootLogger.level == Level.OFF
        logger.level == null

        when:
        loggingManager.start()

        then:
        rootLogger.level != Level.OFF
        logger.level == null

        when:
        loggingManager.stop()

        when:
        allowFileSystemAccess(false)
        snapshot = read(someFile)
        then:
        assertIsMissingFileSnapshot(snapshot, someFile)

        def missingSubfile = someFile.file("subfile")
        when:
        snapshot = read(missingSubfile)
        then:
        assertIsMissingFileSnapshot(snapshot, missingSubfile)

        when:
        allowFileSystemAccess(true)

            }
        """

        when:
        configurationCacheRun "build"

        then:
        output.count("NOT CI") == 1
        configurationCache.assertStateStored()

        when:
        configurationCacheRun "build"

        then:
        output.count("NOT CI") == 1
        configurationCache.assertStateLoaded()

        when:
        configurationCacheRun "build", "-Dci=true"

        // Some cases are skipped, because forkOptions (when configured) must match the resulting toolchain, otherwise the build fails
        what             | when                         | withTool | withJavaHome | withExecutable | withJavaExtension | target
        "current JVM"    | "when nothing is configured" | null     | null         | null           | null              | "current"

        when:
        dep.addArtifact(Mock(DependencyArtifact))

        then:
        thrown(InvalidUserCodeException)
    }

    void "refuses target configuration when attributes present"() {
        given:
        def dep = createDependency("group", "name", "1.0")
        dep.attributes {
            it.attribute(Attribute.of("attribute", String), 'foo')
        }

        when:

        server.start()

        when:
        def a = server.uri("a")
        def b = server.uri("b")

        then:
        a.scheme == "http"
        b.scheme == "http"
        a.toURL().text == "hi"
        b.toURL().text == "hi"

        when:
        server.stop()

        then:
        noExceptionThrown()
    }

    def "succeeds when expected serial requests are made"() {
        given:

        when:
        createInstance(extractedB)

        then:
        def e = thrown(Exception)
        e.cause.cause instanceof UnsupportedOperationException

        when:
        extractedA.STATIC_IN_A()

        then:
        thrown(UnsupportedOperationException)

        when:
        extractedB.STATIC_IN_B()

        then:

            )
        }

        when:
        configurationCacheRun ":jar", "-Dcreator=creator1"

        then:
        assertCreatedBy 'creator1'
        assertStateStored()

        when:
        configurationCacheRun ":jar", "-Dcreator=creator2"

        then:
        assertCreatedBy 'creator2'
        assertStateLoaded()

        when:
        manifestFile.delete()

        def property = propertyWithDefaultValue(String)

        when:
        def p = property.map(transformer)

        then:
        !p.present
        0 * _

        when:
        property.set("123")
        p.present

        then:
        1 * transformer.transform("123") >> "present"
        0 * _

        when:
        def r = p.get()

        then:
        r == "321"

        v3.pom.expectGet()
        v3.artifact.expectGet()

        when:
        configurationCacheRun("resolve1")

        then:
        configurationCache.assertStateStored()
        outputContains("result = [lib-1.3.jar]")

        when: // run again with different tasks, to verify behaviour when version list is already cached when configuration cache entry is written
        configurationCacheRun("resolve2")