def "multiple threads can locate services"() {
        def registry = new DefaultServiceRegistry()
        registry.addProvider(new ServiceRegistrationProvider() {
            @Provides
            String createString(Integer value) {
                return value.toString()
            }

            @Provides
            Integer createInteger() {
                return 12
            }

            @Provides

namespace tflite {

std::string CreateRuntimeMetadata() {
  flatbuffers::FlatBufferBuilder fb_builder;

  std::vector<flatbuffers::Offset<flatbuffers::String>> device_names = {
      fb_builder.CreateString("GPU"), fb_builder.CreateString("CPU")};

  const auto hardwares =
      CreateHardwareMetadata(fb_builder, fb_builder.CreateVector(device_names));
  const auto ops = {
      CreateOpMetadata(fb_builder, 0, 0,

    @Provides
    Integer createInteger(Runnable action) {
        action.run();
        return 123;
    }

    @Provides
    GenericRunnable<String> createString() {
        return new GenericRunnable<String>() {
            public void run() {
            }
        };
    }

}

flatbuffers::Offset<OperatorCode> CreateOperatorCodeDirect(
    flatbuffers::FlatBufferBuilder &_fbb, BuiltinOperator builtin_code,
    const char *custom_code, int32_t version) {
  auto custom_code__ = custom_code ? _fbb.CreateString(custom_code) : 0;
  int8_t deprecated_builtin_code =
      static_cast<int8_t>(BuiltinOperator_PLACEHOLDER_FOR_GREATER_OP_CODES);
  if (builtin_code < BuiltinOperator_PLACEHOLDER_FOR_GREATER_OP_CODES) {

      }
    });
  }

  // Build the flatbuffer.
  std::vector<flatbuffers::Offset<flatbuffers::String>> hardwares;
  for (const auto& kv : *hardware_names) {
    hardwares.push_back(builder->CreateString(kv.first));
  }

  return CreateHardwareMetadata(*builder, builder->CreateVector(hardwares));
}

}  // namespace

std::optional<std::string> ExportRuntimeMetadata(mlir::ModuleOp module) {