def "can set untyped using provider"() {
        def provider = supplierWithValues(someValue(), someValue())

        given:
        def property = propertyWithNoValue()
        property.setFromAnyValue(provider)

        expect:
        property.present
        property.get() == someValue()
    }

    def "convention value is used before value has been set"() {
        def property = propertyWithNoValue()

        buildIdentified()

        def loadBuildOp = operations.only(LoadBuildBuildOperationType)

        def evaluateSettingsOp = operations.only(EvaluateSettingsBuildOperationType)
        assert evaluateSettingsOp.parentId == loadBuildOp.id

        def configureBuildOp = operations.only(ConfigureBuildBuildOperationType)

        def loadProjectsOp = operations.only(LoadProjectsBuildOperationType)

    def classpathWalker = new ClasspathWalker(TestFiles.fileSystem())
    def classpathBuilder = new DefaultClasspathBuilder(TestFiles.tmpDirTemporaryFileProvider(testDirectoryProvider.createDir("tmp")))
    def fileSystemAccess = TestFiles.fileSystemAccess()
    def globalCacheLocations = Stub(GlobalCacheLocations)
    def fileLockManager = Stub(FileLockManager)
    def agentStatus = Stub(AgentStatus) {

    }

    def "can use test threads to define instants"() {
        def worker = new Worker(executor)

        given:
        def action = {
            instant.actionExecuted
        }

        when:
        worker.runLater(action)
        worker.stop()

        then:
        instant.actionExecuted
    }

    def "can use arbitrary thread to define an instant"() {

    }

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

                    $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),

    }

    def "ignores external module jar from runtime ClassLoader"() {
        def classesDir = tmpDir.createDir("some-module/build/classes/java/main")
        def staticResourcesDir = tmpDir.createDir("some-module/src/main/resources")
        def cl = classLoaderFor([externalDependency, classesDir, resourcesDir, staticResourcesDir, externalRuntimeDep])
        def registry = new DefaultModuleRegistry(cl, ClassPath.EMPTY, null)

        expect: