cPCHCompile.macros = [def: "value"]
        cPCHCompile.objectFileDir = temporaryFolder.file("outputFile")
        cPCHCompile.source sourceFile
        execute(cPCHCompile)

        then:
        _ * toolChain.outputType >> "c"
        platform.getName() >> "testPlatform"
        platform.getArchitecture() >> Mock(ArchitectureInternal) { getName() >> "arch" }

  args[0].shape = TensorShape({1, 2});
  args[0].constant_value = GetInput(0);
  args[0].initialized = true;

  TF_ASSERT_OK_AND_ASSIGN(
      auto graph,
      CreateSingleOpGraph(*node_def(), args, single_op_arg.output_dtypes));

  const auto& node_name_index = graph->BuildNodeNameIndex();

  const Node* identity_node = node_name_index.at("identity_op");
  EXPECT_EQ(identity_node->op_def().name(), "Identity");

        objCCompile.objectFileDir = temporaryFolder.file("outputFile")
        objCCompile.source sourceFile
        objCCompile.setPreCompiledHeader pch
        execute(objCCompile)

        then:
        _ * toolChain.outputType >> "objc"
        platform.getName() >> "testPlatform"
        platform.getArchitecture() >> Mock(ArchitectureInternal) { getName() >> "arch" }

        objCppCompile.source sourceFile
        objCppCompile.setPreCompiledHeader pch
        execute(objCppCompile)

        then:
        _ * toolChain.outputType >> "objcpp"
        platform.getName() >> "testPlatform"
        platform.getArchitecture() >> Mock(ArchitectureInternal) { getName() >> "arch" }

  EXPECT_EQ(DEVICE_MEMORY, kernel_->input_memory_types()[0]);
  EXPECT_EQ(HOST_MEMORY, kernel_->input_memory_types()[1]);

  EXPECT_EQ(1, kernel_->num_outputs());
  EXPECT_EQ(DT_FLOAT, kernel_->output_type(0));
  EXPECT_EQ(DEVICE_MEMORY, kernel_->output_memory_types()[0]);
}

TEST_F(XlaKernelCreatorTest, FailsIfXlaCompileAttrNotSet) {
  FunctionDef fdef = XTimesY();
  Init({fdef});

        cppCompile.objectFileDir = temporaryFolder.file("outputFile")
        cppCompile.source sourceFile
        cppCompile.setPreCompiledHeader pch
        execute(cppCompile)

        then:
        _ * toolChain.outputType >> "cpp"
        platform.getName() >> "testPlatform"
        platform.getArchitecture() >> Mock(ArchitectureInternal) { getName() >> "arch" }

	(*ConfigPair)(nil), // 1: config.ConfigPair
}
var file_pkg_test_config_mock_config_proto_depIdxs = []int32{
	1, // 0: config.MockConfig.pairs:type_name -> config.ConfigPair
	1, // [1:1] is the sub-list for method output_type
	1, // [1:1] is the sub-list for method input_type
	1, // [1:1] is the sub-list for extension type_name
	1, // [1:1] is the sub-list for extension extendee
	0, // [0:1] is the sub-list for field type_name
}

        includes = getProject().files();
        this.targetPlatform = objectFactory.property(NativePlatform.class);
        this.toolChain = objectFactory.property(NativeToolChain.class);
        getInputs().property("outputType", new Callable<String>() {
            @Override
            public String call() throws Exception {
                NativeToolChainInternal nativeToolChain = (NativeToolChainInternal) toolChain.get();

		return resultError("compilation failed: "+issues.String(), apiservercel.ErrorTypeInvalid)
	}

	found := false
	returnTypes := expressionAccessor.ReturnTypes()
	for _, returnType := range returnTypes {
		if ast.OutputType() == returnType || cel.AnyType == returnType {
			found = true
			break
		}
	}
	if !found {
		var reason string
		if len(returnTypes) == 1 {

  // directly to create the back edge.
  NodeBuilder::NodeOut enter_input(enter_output.node(), enter_output.index());

  const int next_output_index = 0;
  DataType dtype = enter_output.node()->output_type(0);
  NodeBuilder::NodeOut next_input(NextIterationName(scope, loop_var_idx),
                                  next_output_index, dtype);

  std::vector<NodeBuilder::NodeOut> input_list({enter_input, next_input});