ASSERT_TRUE(foo.has_value());
  EXPECT_EQ(*foo, 1);

  absl::optional<int> foo_bar =
      internal::FindNodeAtPath("foo.bar", object_graph);
  ASSERT_TRUE(foo_bar.has_value());
  EXPECT_EQ(*foo_bar, 3);

  absl::optional<int> foo_bar_parent =
      internal::FindNodeAtPath("foo.bar.parent", object_graph);
  ASSERT_TRUE(foo_bar_parent.has_value());
  EXPECT_EQ(*foo_bar_parent, 1);

        File oldFile = new File(args[0])
        File newFile = new File(args[1])
        PerformanceTestScenarioDefinition oldJson = new ObjectMapper().readValue(oldFile, PerformanceTestScenarioDefinition).sort()
        PerformanceTestScenarioDefinition newJson = new ObjectMapper().readValue(newFile, PerformanceTestScenarioDefinition).sort()
        if (oldJson != newJson) {

				"creationTimestamp":          "2009-11-10T23:00:00Z",
				"deletionTimestamp":          "2010-11-10T23:00:00Z",
				"labels": map[string]interface{}{
					"test_label": "test_value",
				},
				"annotations": map[string]interface{}{
					"test_annotation": "test_value",
				},
				"ownerReferences": []interface{}{
					map[string]interface{}{
						"kind":       "Pod",
						"name":       "poda",
						"apiVersion": "v1",

    auto device_name = GetDeviceName(&inst);

    if (device_name.has_value()) {
      // Add per device costs if present.
      auto per_device_cost = GetPerDeviceCosts(hardware_map, &inst);
      flatbuffers::Offset<flatbuffers::Vector<float>> per_device_cost_offset;

      if (per_device_cost.has_value()) {
        per_device_cost_offset = builder->CreateVector(*per_device_cost);
      }

    return zero_point + static_cast<int32_t>(std::round(f / scale));
  };

  if (rmin.has_value() && rmax.has_value()) {
    return {std::max(qmin, quantize(rmin.value())),
            std::min(qmax, quantize(rmax.value()))};
  } else if (rmin.has_value()) {
    return {std::max(qmin, quantize(rmin.value())), qmax};
  } else if (rmax.has_value()) {
    return {qmin, std::min(qmax, quantize(rmax.value()))};
  } else {

  {
    mutex_lock lock(entry->mu);
    if (compile_state.has_value()) {
      entry->compile_state = *compile_state;
    }
    if (compilation_status.has_value()) {
      entry->compilation_status = *compilation_status;
    }
    if (compilation_result.has_value()) {
      entry->compilation_result = std::move(*compilation_result);
    }
    if (executable.has_value()) {
      entry->executable = std::move(*executable);
    }

		return fmt.Errorf("couldn't find %v field in %T", fieldName, v.Interface())
	}
	destValue, err := conversion.EnforcePtr(dest)
	if err != nil {
		return err
	}
	if field.Type().AssignableTo(destValue.Type()) {
		destValue.Set(field)
		return nil
	}
	if field.Type().ConvertibleTo(destValue.Type()) {
		destValue.Set(field.Convert(destValue.Type()))
		return nil
	}

                                      &read_value_handle));
  Status status;
  AbstractTensorPtr read_value(read_value_handle->Resolve(&status));
  TF_EXPECT_OK(status);
  EXPECT_FLOAT_EQ(42.0, *static_cast<float*>(read_value->Data()));
}

}  // namespace

  MockXlaCompilerClient mock_client;
  auto executable = persistor.TryToLoadExecutable(
      123, "signature_string", DefaultXlaOptions(), compilation_result_add_,
      &mock_client);
  EXPECT_FALSE(executable.has_value());
}

TEST_F(DeviceExecutionPersistorTest, LoadSuccess) {
  XlaDeviceExecutablePersistor::Config config(
      /*persistent_cache_directory=*/cache_dir_,
      /*disable_strict_signature_checks=*/false,

  auto output = GetWeightComponentSpec(quant_options);
  EXPECT_TRUE(output.has_value());
}

TEST(TfOpQuantSpecTest, WeightComponentSpecDoNotExist) {
  QuantizationOptions quant_options;
  auto output = GetWeightComponentSpec(quant_options);
  EXPECT_FALSE(output.has_value());
}

}  // namespace