* java.util.concurrent.CompletableFuture#thenAcceptAsync}.
   *
   * @param callback The callback to invoke when this {@code Future} is completed.
   * @param executor The executor to run {@code callback} when the future completes.
   */
  public final void addCallback(FutureCallback<? super V> callback, Executor executor) {
    Futures.addCallback(this, callback, executor);
  }

                Request
                  .Builder()
                  .url(server.url("/a"))
                  .build()
              try {
                val callbackA = RecordingCallback()
                client.newCall(requestA).enqueue(callbackA)
                callbackA.await(requestA.url).assertBody("a")
              } catch (e: Exception) {
                throw RuntimeException(e)
              }
            }

			callbacks: []callback{{h: c1}, {h: c2, before: "c4", after: "c5"}, {h: c3, before: "c4", after: "*"}, {h: c4, after: "*"}, {h: c5, before: "*"}},
			results:   []string{"c5", "c1", "c2", "c3", "c4"},
		},
	}

	for idx, data := range datas {
		db, err := gorm.Open(nil, nil)
		if err != nil {
			t.Fatal(err)
		}
		callbacks := db.Callback()

		for _, c := range data.callbacks {
			var v interface{} = callbacks.Create()

      |
      """.trimMargin(),
    )
    assertThat(callbacks).isEmpty()
  }

  private fun consumeEvents(source: String) {
    val callback: ServerSentEventReader.Callback =
      object : ServerSentEventReader.Callback {
        override fun onEvent(
          id: String?,
          type: String?,
          data: String,
        ) {
          callbacks.add(Event(id, type, data))
        }

            Consumer<RESPONSE> callback;
            while ((callback = doneCallbacks.poll()) != null) {
                executeCallbacks.add(callback);
            }
        }
        if (executeCallbacks.size() > 0) {
            try {
                executeCallbacks.stream().forEach(callback -> callback.accept(response));
            } catch (final Exception ignore) {}
        }

  override fun handle(callbacks: Array<Callback>) {
    for (callback in callbacks) {
      if (callback is PasswordCallback) {
        val console = System.console()

        if (console != null) {
          callback.password = console.readPassword(callback.prompt)
        } else {
          System.err.println(callback.prompt)
          callback.password =
            System.`in`

                            },
                        },
                        "callbacks": {
                            "callback_route": {
                                "{$callback_url}/callback/": {
                                    "get": {
                                        "summary": "Callback Route",
                                        "operationId": "callback_route__callback_url__callback__get",

   *
   * @param future The future attach the callback to.
   * @param callback The callback to invoke when {@code future} is completed.
   * @param executor The executor to run {@code callback} when the future completes.
   * @since 10.0
   */
  public static <V extends @Nullable Object> void addCallback(
      ListenableFuture<V> future, FutureCallback<? super V> callback, Executor executor) {

                            },
                        },
                        "callbacks": {
                            "event_callback": {
                                "{$callback_url}/events/{$request.body.title}": {
                                    "get": {
                                        "summary": "Event Callback",

        NameCallback nc = new NameCallback("user:");
        PasswordCallback pc = new PasswordCallback("pass:", false);

        // Exercise callback handler with both callbacks supplied
        Callback[] cbs = new Callback[] { nc, pc };
        auth.handle(cbs);

        // Name should be formatted as username@domain
        assertEquals("user@DOM", nc.getName());
        // Password should be set