* 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);
  }

			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))
        }

   *
   * @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) {

  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",

        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

	}

	p2.Code = "dont_save"
	if DB.Save(&p2).Error == nil {
		t.Fatalf("An error from before save callbacks happened when update with invalid value")
	}

	p3 := Product{Code: "dont_delete", Price: 100}
	DB.Save(&p3)
	if DB.Delete(&p3).Error == nil {
		t.Fatalf("An error from before delete callbacks happened when delete")
	}

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

     * {@inheritDoc}
     *
     * @see javax.security.auth.callback.CallbackHandler#handle(javax.security.auth.callback.Callback[])
     */
    @Override
    public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException {
        for (Callback cb : callbacks) {
            if (log.isDebugEnabled()) {
                log.debug("Got callback " + cb.getClass().getName());
            }