class TaskNodeFactoryTest extends Specification {
    def gradle = Stub(GradleInternal)
    def project = Stub(ProjectInternal)
    TaskNodeFactory factory
    def a = task('a')
    def b = task('b')
    def c = task('c')
    def d = task('d')
    def e = task('e')

    def setup() {
        project.gradle >> gradle
        project.pluginManager >> Stub(PluginManagerInternal)

        def rootDir = new File("dummy")
        def target = Stub(GradleProjectIdentity)
        def buildState1 = Stub(BuildState)
        def buildState2 = Stub(BuildState)
        def buildState3 = Stub(BuildState)
        def projects3 = Stub(BuildProjectRegistry)
        def projectState = Stub(ProjectState)
        def model = new Object()

        given:

        variant1.artifacts.add(Stub(PublishArtifact))

        conf2.artifacts.add(Mock(PublishArtifact))
        ConfigurationVariant variant2 = conf2.outgoing.getVariants().create("variant2")
        variant2.attributes.attribute(Attribute.of("foo2", String), "bar2")
        variant2.artifacts.add(Stub(PublishArtifact))
        variant2.artifacts.add(Stub(PublishArtifact))

        when:

        testDescriptor.name >> "method"
        testDescriptor.displayName >> "method"

        def suiteStartEvent = Stub(TestStartEvent) {
            getParentId() >> null
        }
        def testStartEvent = Stub(TestStartEvent) {
            getParentId() >> "suite"
        }
        def finishEvent = Stub(TestCompleteEvent) {
            getResultType() >> TestResult.ResultType.SUCCESS
        }

    final toolChain = new GccToolChain(instantiator , "gcc", Stub(BuildOperationExecutor), OperatingSystem.current(), fileResolver, Stub(ExecActionFactory), Stub(CompilerOutputFileNamingSchemeFactory), Stub(CompilerMetaDataProviderFactory), Stub(SystemLibraryDiscovery), Stub(WorkerLeaseService))

    def "provides default tools"() {
        def action = Mock(Action)

        when:

            assert context.current().source == source
        }

        and:
        context.current() == null
    }

    def "can nest application"() {
        def source = Stub(UserCodeSource)
        def source2 = Stub(UserCodeSource)
        def action = Mock(Action)
        def action2 = Mock(Action)
        def id1

        when:
        context.apply(source, action)

        then:

        compileOptions = TestUtil.newInstance(CompileOptions, TestUtil.objectFactory())
        it
    }
    AnnotationProcessorDetector detector = Stub(AnnotationProcessorDetector)
    Compiler<JavaCompileSpec> delegate = Stub(Compiler)

    AnnotationProcessorDiscoveringCompiler compiler = new AnnotationProcessorDiscoveringCompiler(delegate, detector)

            return Stub(BuildResult) {
                getModel() >> actionResult
            }
        }
        1 * action.execute({ it instanceof BuildController }) >> 'result'
    }

    def "adapts build action failure"() {
        def action = Mock(BuildAction)
        def parameters = Stub(ConsumerOperationParameters)
        def failure = new RuntimeException()

    }

    def "allows provider convertible of type MinimalExternalModuleDependency as an input"() {
        given:
        def providerConvertible = Stub(ProviderConvertible.class)
        def provider = Stub(Provider.class)
        def dependency = Stub(MinimalExternalModuleDependency.class)
        dependency.module >> DefaultModuleIdentifier.newId("org.foo", "bar")

    def jApiClassifier = Stub(JApiClass) // represents interfaces, enums and annotations
    def jApiMethod = Stub(JApiMethod)
    def jApiField = Stub(JApiField) // represents fields and enum literals
    def jApiConstructor = Stub(JApiConstructor)
    def incubatingAnnotation = Stub(JApiAnnotation)
    def deprecatedAnnotation = Stub(JApiAnnotation)
    def overrideAnnotation = Stub(JApiAnnotation)