}
)";

void ExpectHasSubstr(StringPiece s, StringPiece expected) {
  EXPECT_TRUE(absl::StrContains(s, expected))
      << "'" << s << "' does not contain '" << expected << "'";
}

void ExpectDoesNotHaveSubstr(StringPiece s, StringPiece expected) {
  EXPECT_FALSE(absl::StrContains(s, expected))
      << "'" << s << "' contains '" << expected << "'";
}

void ExpectSubstrOrder(const string& s, const string& before,

    ctx_.reset(ctx_raw);
  }
};

template <typename T>
void ExpectEquals(AbstractTensorHandle* t, T expected) {
  TF_Tensor* result_t;
  Status s = tensorflow::GetValue(t, &result_t);
  ASSERT_TRUE(s.ok()) << s.message();
  auto value = static_cast<T*>(TF_TensorData(result_t));
  EXPECT_EQ(*value, expected);
  TF_DeleteTensor(result_t);
}

TEST_P(VariableTest, CreateAssignReadDestroy) {

  TF_EXPECT_OK(AttrValueHasType(*kernel_attr, "string"));
  EXPECT_EQ(kernel_attr->s(), "AddWithKernelLabel");
}

TEST(CCOpTest, ColocateWith) {
  Scope root = Scope::NewRootScope();
  auto c1 = Const(root.WithOpName("c1"), 1);
  auto c2 = Const(root.WithOpName("c2").ColocateWith(c1), 2);
  std::vector<string> constraints;
  GetColocationConstraints(c2, &constraints);
  EXPECT_EQ(constraints[0], "loc:@c1");

	// Everything must match.
	if !matchParams(pass, expect.args, args, "") || !matchParams(pass, expect.results, results, "") {
		expectFmt := id.Name + "(" + argjoin(expect.args) + ")"
		if len(expect.results) == 1 {
			expectFmt += " " + argjoin(expect.results)
		} else if len(expect.results) > 1 {
			expectFmt += " (" + argjoin(expect.results) + ")"
		}

		actual := typeString(sign)
		actual = strings.TrimPrefix(actual, "func")

    return cpu_allocator();
  }
};

// Helper for comparing output and expected output
void ExpectSummaryMatches(const Summary& actual, const string& expected_str) {
  Summary expected;
  ASSERT_TRUE(protobuf::TextFormat::ParseFromString(expected_str, &expected));
  EXPECT_EQ(expected.DebugString(), actual.DebugString());
}

void TestScalarSummaryOp(Tensor* tags, Tensor* values, string expected_output,

  EXPECT_EQ(SavedModelReadApi("bar").value(), 1);
  SavedModelReadCount("2").IncrementBy(1);
  EXPECT_EQ(SavedModelReadCount("2").value(), 1);

  SavedModelReadApi("baz").IncrementBy(1);
  EXPECT_EQ(SavedModelReadApi("baz").value(), 1);
  SavedModelReadCount("2").IncrementBy(1);
  EXPECT_EQ(SavedModelReadCount("2").value(), 2);
}

TEST(MetricsTest, TestCheckpointRead) {

  TF_ASSERT_OK_AND_ASSIGN(auto key, BuildSampleSignature("foo"));
  Cache::Value cache_value = cache->LookupOrCreate(key);

  EXPECT_EQ(cache_value.compile_state, DeviceCompileState::kUncompiled);
  EXPECT_EQ(cache_value.request_count, 1);
  EXPECT_EQ(cache_value.compilation_result, nullptr);
  EXPECT_EQ(cache_value.executable, nullptr);
}

TEST(DeviceCompilationCacheTest, IncrementRequestCountOnLookup) {

  EXPECT_EQ(arg_node->op_def().name(), "_Arg");
  EXPECT_EQ(arg_node->attrs().FindByString("T")->type(), DT_FLOAT);

  const Node* retval_node = node_name_index.at("_retval0");
  EXPECT_EQ(retval_node->op_def().name(), "_Retval");
  EXPECT_EQ(retval_node->attrs().FindByString("T")->type(), DT_FLOAT);

  EXPECT_EQ(identity_node->num_outputs(), 1);
  EXPECT_EQ(retval_node->num_inputs(), 1);
  const Node* retval_input_node = nullptr;

  foo.Set(String("b"), Integer(33));
  EXPECT_EQ(foo.Get<Integer>(String("b"))->get(), 33);
}

TEST(ObjectTest, TestTuple) {
  Tuple foo(String("a"), Integer(33), Float(10.f));
  EXPECT_EQ(foo.size(), 3);
  EXPECT_EQ(foo.Get<Integer>(1)->get(), 33);
}

TEST(ObjectTest, TestList) {
  List l;
  EXPECT_EQ(l.size(), 0);
  l.append(Integer(3));
  EXPECT_EQ(l.Get<Integer>(0)->get(), 3);
  EXPECT_EQ(l.size(), 1);
}

  auto context = CreateContext();

  EXPECT_EQ(ToBfloat16Type(Float8E4M3FNType::get(context.get())),
            Float8E4M3FNType::get(context.get()));
  EXPECT_EQ(ToBfloat16Type(Float16Type::get(context.get())),
            Float16Type::get(context.get()));
  EXPECT_EQ(ToBfloat16Type(BFloat16Type::get(context.get())),
            BFloat16Type::get(context.get()));
  EXPECT_EQ(ToBfloat16Type(Float32Type::get(context.get())),