}

    def "tasks have common output directories"() {
        def sourceFile1 = file('source1/source1.txt')
        sourceFile1 << 'a'
        def sourceFile2 = file('source2/source2.txt')
        sourceFile2 << 'b'
        def targetFile1 = file('target/source1.txt')
        def targetFile2 = file('target/source2.txt')
        def taskPath = ':copyAll'

        buildFile << """

    def listenerManager = new DefaultListenerManager(Scope.BuildSession)
    def actionExecutor = Mock(BuildSessionActionExecutor)
    def userHomeServiceRegistry = Mock(GradleUserHomeScopeServiceRegistry)
    def crossBuildState = Mock(CrossBuildSessionState)
    def startParameter = new StartParameterInternal()
    def buildRequestMetadata = Mock(BuildRequestMetaData)
    def clientMetadata = Mock(BuildClientMetaData)

        def p = container.get(spec)
        p.present
        p.get() == binary2
    }

    def "fires finalize event for element by spec after configuration has completed"() {
        def spec = Stub(Spec)
        def binary1 = Stub(SwiftBinary)
        def binary2 = Stub(SwiftBinary)
        def action1 = Mock(Action)
        def action2 = Mock(Action)
        def finalizeAction = Mock(Action)

    }

    def 'decorates listeners that are a combination of listener interfaces'() {
        given:
        def settingsEvaluatedArg = Mock(Settings)
        def projectsLoadedArg = Mock(Gradle)
        def beforeEvaluateArg = Mock(Project)
        def graphPopulatedArg = Mock(TaskExecutionGraph)
        def listener = Mock(ComboListener)
        def id
        def decoratedListener

        when:

    def workSource = Mock(WorkSource)
    def worker = Mock(Action)
    def executorFactory = Mock(ExecutorFactory)
    def cancellationHandler = Mock(BuildCancellationToken)
    def coordinationService = new DefaultResourceLockCoordinationService()
    def workerLeaseService = Mock(WorkerLeaseService)
    def workerLease = Mock(WorkerLeaseRegistry.WorkerLease)

                message == "badness"
                cause.message == "nullness"
            }
        }
    }

    def "extracts metadata information from LAE"() {
        given:
        def l = 57
        def c = new RuntimeException("!")
        def s = "source"
        def e = new LocationAwareException(c, s, l)

        expect:
        with(ExceptionMetadataHelper.getMetadata(e)) {

class DefaultRuntimeClasspathNormalizationTest extends Specification {
    def "default normalization has no cached state"() {
        when:
        def normalization = new DefaultRuntimeClasspathNormalization()
        then:
        normalization.computeCachedState() == null
    }

    def "file ignores can be restored from the cached state"() {
        given:
        def originalNormalization = new DefaultRuntimeClasspathNormalization()

        details.maySupportModel(CustomModel)
    }

    def "delegates to connection to run build action"() {
        def action = Mock(BuildAction)
        def parameters = Stub(ConsumerOperationParameters)
        def buildController = Mock(InternalBuildController)

        when:
        def result = connection.run(action, parameters)

        then:
        result == 'result'

                    $num_bits, $narrow_range)))>;

def LegalizeFill : Pat<(TF_FillOp $arg, $value), (TFL_FillOp $arg, $value)>;

def LegalizeFloor : Pat<(TF_FloorOp $arg), (TFL_FloorOp $arg)>;

def LegalizeLeakyRelu : Pat<(TF_LeakyReluOp $arg, F32Attr:$a),
                            (TFL_LeakyReluOp $arg, $a)>;

def LegalizeLog : Pat<(TF_LogOp $arg), (TFL_LogOp $arg)>;

def LegalizeLog1p : Pat<
  (TF_Log1pOp F32Tensor:$arg),

        [type, eol] << EOLS
    }

    def "append text that contains multiple lines [#type]"() {
        def output = output()

        when:
        output.text("a${eol}b")

        then:
        result.toString() == "[a]{eol}{start}[b]"

        where:
        [type, eol] << EOLS
    }

    def "append text that ends with eol [#type]"() {
        def output = output()

        when: