CreateLoop(
      [](const Scope& s, const std::vector<Output>& inputs, Output* output) {
        *output = ops::Placeholder(s, DT_FLOAT);
        return s.status();
      },
      AddOneBody, error::INVALID_ARGUMENT,
      "BuildWhileLoop: 'cond' argument must return a boolean output, got "
      "float");
}

// TODO(skyewm): test bad cond output shape

TEST_F(WhileLoopTest, NullCondOutputNode) {
  Init(1);

               std::nullopt, std::nullopt);
  cache_value = cache->Lookup(key);

  EXPECT_EQ(cache_value->compile_state, DeviceCompileState::kCompiled);
  EXPECT_EQ(cache_value->compilation_status.code(), error::INVALID_ARGUMENT);
  EXPECT_TRUE(cache_value->compilation_result == nullptr);
  EXPECT_TRUE(cache_value->executable == nullptr);

  cache->Store(key, std::nullopt, std::nullopt, std::move(compilation_result),

  tags.matrix<tstring>()(1, 0) = "tag2";
  values.vec<float>()(0) = 1.0f;
  values.vec<float>()(1) = -2.0f;
  TestScalarSummaryOp(&tags, &values, "tags and values are not the same shape",
                      error::INVALID_ARGUMENT);
}

TEST(ScalarSummaryOpTest, Error_WrongValuesTags) {
  Tensor tags(DT_STRING, {2});
  Tensor values(DT_FLOAT, {2, 1});
  tags.vec<tstring>()(0) = "tag1";
  tags.vec<tstring>()(1) = "tag2";

  absl::Status another_cc_status(StatusFromTF_Status(s));
  ASSERT_FALSE(another_cc_status.ok());
  ASSERT_EQ(std::string("some error"), another_cc_status.message());
  ASSERT_EQ(error::INVALID_ARGUMENT, another_cc_status.code());
  // Ensure the payloads are not lost during conversions
  ASSERT_EQ(cc_status.GetPayload("key1"), another_cc_status.GetPayload("key1"));

var SupportedGRPCStatus = map[string]codes.Code{
	"OK":                  codes.OK,
	"CANCELLED":           codes.Canceled,
	"UNKNOWN":             codes.Unknown,
	"INVALID_ARGUMENT":    codes.InvalidArgument,
	"DEADLINE_EXCEEDED":   codes.DeadlineExceeded,
	"NOT_FOUND":           codes.NotFound,
	"ALREADY_EXISTS":      codes.AlreadyExists,
	"PERMISSION_DENIED":   codes.PermissionDenied,

      persistor.TryToPersistExecutable(
          /*signature_hash=*/123, "signature_string", DefaultXlaOptions(),
          compilation_result_add_, *executable, &mock_client),
      testing::StatusIs(error::INVALID_ARGUMENT));
}

TEST_F(DeviceExecutionPersistorTest, PersistExecutableEmpty) {
  XlaDeviceExecutablePersistor::Config config(
      /*persistent_cache_directory=*/cache_dir_,

  TestBitcastOp(&int32_input, DT_UINT8, TensorShape({4, 6, 4}), error::OK);
}

TEST(BitcastOpTest, TestImpossibleCast) {
  Tensor int8_input(DT_UINT8, {1});
  TestBitcastOp(&int8_input, DT_UINT32, TensorShape(), error::INVALID_ARGUMENT);
}

PartialTensorShape S(std::initializer_list<int64_t> dims) {
  return PartialTensorShape(dims);
}

TEST(BitcastOpTest, TestShapeInference_LargerShape) {
  const OpRegistrationData* reg;

  Status s = RunModel(RecordOperationWithNullGradientFunctionModel, ctx.get(),
                      {x.get()}, absl::MakeSpan(outputs),
                      /*use_function=*/!std::get<2>(GetParam()));
  ASSERT_EQ(error::INVALID_ARGUMENT, s.code());
  ASSERT_EQ(
      "Provided null gradient_function for 'Neg'.\nIf the intent is to treat "
      "this op as non-differentiable consider using RegisterNotDifferentiable "

  // CHECK: %0 = mhlo.constant dense<[32, 12, 12, 64]> : tensor<4xi32>
  // CHECK-NEXT: %1 = "tf.RandomUniform"(%0) : (tensor<4xi32>) -> tensor<32x12x12x64xf32>
  // expected-remark@+1 {{failed to create tf2xla kernel: INVALID_ARGUMENT: NodeDef missing attrs 'seed2', 'seed' from}}
  %cst = "tf.Const"() {value = dense<[32, 12, 12, 64]> : tensor<4xi32>} : () -> tensor<4xi32>
  %0 = "tf.RandomUniform"(%cst) {} : (tensor<4xi32>) -> tensor<32x12x12x64xf32>

  std::unique_ptr<Graph> graph;
  Status failure_status = BuildXlaOps(root, fdef_lib, &graph);
  ASSERT_FALSE(failure_status.ok());
  EXPECT_EQ(failure_status.code(), error::INVALID_ARGUMENT);
}

TEST_F(BuildXlaOpsTest, OnNonXlaDevice) {
  Scope root = Scope::NewRootScope().ExitOnError();

  FunctionDefLibrary fdef_lib =
      CreateFunctionDefLibWithConstFunction("cluster_0");