result.graphState == graphState
    }

    def "cannot get id when no result has been specified"() {
        when:
        result.moduleVersionId

        then:
        IllegalStateException e = thrown()
        e.message == 'No result has been specified.'
    }

    def "cannot get state when no result has been specified"() {
        when:
        result.state

        then:

    }

    def "fails on non-static inner class when outer type not provided as first parameter when type takes constructor params"() {
        given:
        services.find(Number) >> 12

        when:
        def inst = instantiator.newInstance(NonStaticWithParams, this, "param")

        then:
        inst.owner == this

        when:
        instantiator.newInstance(NonStaticWithParams, "param")

        def notIgnoredResource = project[notIgnoredResourceName]

        when:
        succeeds project.customTask
        then:
        executedAndNotSkipped(project.customTask)

        when:
        succeeds project.customTask
        then:
        skipped(project.customTask)

        when:
        ignoredResource.changeContents()
        succeeds project.customTask
        then:

        task aTask
        """
        when:
        fails "help", "--task", "bTask"
        then:
        failure.assertHasCause("Task 'bTask' not found in root project '${testDirectory.getName()}'. Some candidates are: 'aTask', 'tasks'")

        when:
        run "help", "--task", "aTask"
        then:
        output.contains "Detailed task information for aTask"

        when:
        fails "help", "--task", "bTask"

        inputs.sourceFiles.empty
    }

    def "can register input file"() {
        when:
        inputs.file("a")
        then:
        inputFileProperties() == ['$1': "a"]
        inputs.files.files == files("a")
    }

    def "can register input file with property name"() {
        when:
        inputs.file("a").withPropertyName("prop")
        then:
        inputFileProperties() == ['prop': "a"]

    def "does not implicitly create an object when closure parameter is used explicitly"() {
        when:
        container.configure {
            it.obj1
        }

        then:
        MissingPropertyException missingProp = thrown()
        missingProp.property == 'obj1'
    }

    def "does not implicitly create an object when container is not being configured"() {
        when:
        container.obj1

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

//     one register with arrangement specifier encoded in the "size:Q" field which can have the following values:
//       8B when size = 00, Q = 0
//       16B when size = 00, Q = 1
//       4H when size = 01, Q = 0
//       8H when size = 01, Q = 1
//       2S when size = 10, Q = 0
//       4S when size = 10, Q = 1
//       2D when size = 11, Q = 1
//       The encoding size = 11, Q = 0 is reserved.
//

        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"