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

                    $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:

        given:
        def action = Mock(Action)

        when:
        def provider = registerService("service", NoParamsServiceImpl, action)

        then:
        1 * action.execute(_)

        when:
        def service = provider.get()

        then:
        service != null
    }

    def "service can be create without action"() {
        when:

class DependencyGraphBuilderTest extends Specification {
    def conflictResolver = Mock(ModuleConflictResolver)
    def idResolver = Mock(DependencyToComponentIdResolver)
    def metaDataResolver = Mock(ComponentMetaDataResolver)
    def attributesSchema = Mock(AttributesSchemaInternal)
    def attributes = ImmutableAttributes.EMPTY
    def moduleReplacements = Mock(ModuleReplacementsData)
    def moduleIdentifierFactory = Mock(ImmutableModuleIdentifierFactory) {

        1 * selectedComponentResult.matches(b.id)
        0 * _

    }

    def "chooses newest non rejected matching version without requiring metadata"() {
        given:
        def a = component('1.2')
        def b = component('1.3')
        def c = component('2.0')
        def d = component('1.1')
        def selectedComponentResult = Mock(ComponentSelectionContext)

        when:

    def "producer task with a dependency in another project will run before destroyer tasks when ordered first (type: #type)"() {
        def foo = subproject(':foo')
        def bar = subproject(':bar')

        def cleanFoo = foo.task('cleanFoo').destroys('build/foo')
        def cleanBar = bar.task('cleanBar').destroys('build/bar')

    }

    def "artifact is attached to child configurations"() {
        given:
        def artifact1 = artifactName()
        def artifact2 = artifactName()
        def artifact3 = artifactName()
        def file1 = new File("artifact-1.zip")
        def file2 = new File("artifact-2.zip")
        def file3 = new File("artifact-3.zip")

        def conf1 = dependencyScope("conf1")

    def listenerManager = new DefaultListenerManager(Scope.BuildTree)
    def services = new DefaultServiceRegistry()

    def setup() {
        services.add(listenerManager)
    }

    def "automatically creates and registers stateful listener when first event is broadcast"() {
        def created = Mock(Runnable)
        def listener = Mock(TestListener)

        when:

    def "creates multi-project application sample when incubating flag = #incubating"() {
        given:
        def dsl = buildDsl
        def language = jvmLanguage.name
        def ext = jvmLanguage.extension
        def settingsFile = dsl.fileNameFor('settings')
        def buildFile = dsl.fileNameFor('build')
        def javaMajorVersion = JavaVersion.current().majorVersion