// TODO(adonovan): make this a library function or method of Info.
func imported(info *types.Info, spec *ast.ImportSpec) *types.Package {
	obj, ok := info.Implicits[spec]
	if !ok {
		obj = info.Defs[spec.Name] // renaming import
	}
	return obj.(*types.PkgName).Imported()

#define TENSORFLOW_COMPILER_JIT_COMPILABILITY_CHECK_UTIL_H_

#include <string>

#include "absl/algorithm/container.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "tensorflow/compiler/jit/defs.h"
#include "tensorflow/compiler/jit/device_util.h"
#include "tensorflow/compiler/jit/flags.h"
#include "tensorflow/compiler/jit/resource_operation_safety_analysis.h"
#include "tensorflow/compiler/tf2xla/const_analysis.h"

)

gentbl_cc_library(
    name = "runtime_fallback_ops_inc_gen",
    tbl_outs = [
        (
            ["-gen-op-decls"],
            "runtime_fallback_ops.h.inc",
        ),
        (
            ["-gen-op-defs"],
            "runtime_fallback_ops.cc.inc",
        ),
    ],
    tblgen = "@llvm-project//mlir:mlir-tblgen",
    td_file = "runtime_fallback/runtime_fallback_ops.td",
    deps = [":runtime_fallback_ops_td_files"],
)

        def file = tmpDir.file("missing")
        def outFile = tmpDir.file("out")

        expect:
        def resource = new LocalFileStandInExternalResource(file, TestFiles.fileSystem())
        def result = resource.writeToIfPresent(outFile)
        result == null
        !outFile.exists()
    }

    def "can fail on missing file when copying to file"() {
        def file = tmpDir.file("missing")

        expect:
        def original = "abc"
        def isolated = isolatableFactory.isolate(original)
        isolated instanceof StringValueSnapshot
        isolated.isolate().is(original)
    }

    def "can coerce string value"() {
        expect:
        def original = "abc"
        def isolated = isolatableFactory.isolate(original)
        isolated.coerce(String).is(original)

    def "can merge composite set into itself"() {
        def action1 = Mock(Action)
        def action2 = Mock(Action)
        def original = ImmutableActionSet.of(action1, action2)

        expect:
        def set = original.mergeFrom(original)
        set.is(original)
    }

    def "can merge composite sets with common ancestors"() {
        def action1 = Mock(Action)
        def action2 = Mock(Action)

    def "selects candidate with subset of attributes and whose values match"() {
        given:
        def matcher = new DefaultAttributeMatcher(schema)

        def usage = Attribute.of('usage', String)
        schema.attribute(usage)
        def other = Attribute.of('other', String)
        schema.attribute(other)

        def candidate1 = attributes(usage: "match")
        def candidate2 = attributes(usage: "no match")

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