interface AsyncDns {
  /**
   * Query DNS records for `hostname`, in the order they are received.
   */
  fun query(
    hostname: String,
    callback: Callback,
  )

  /**
   * Callback to receive results from the DNS Queries.
   */
  @ExperimentalOkHttpApi
  interface Callback {
    /**
     * Return addresses for a dns query for a single class of IPv4 (A) or IPv6 (AAAA).

    boolean ran = false;
    @Nullable Callback callback = null;

    public SimpleTearDown() {}

    public SimpleTearDown(Callback callback) {
      this.callback = callback;
    }

    @Override
    public void tearDown() throws Exception {
      if (callback != null) {
        callback.run();
      }
      ran = true;
    }
  }

    * Send a notification back to the API user (the external developer), as a callback.
        * At this point is that the API will somehow send a POST request to the
            external API with the notification of the invoice event
            (e.g. "payment successful").
    """
    # Send the invoice, collect the money, send the notification (the callback)
    return {"msg": "Invoice received"}

        ComponentUtil.register(new WebConfigBhv() {
            @Override
            public ListResultBean<WebConfig> selectList(final CBCall<WebConfigCB> cbLambda) {
                cbLambda.callback(cb);
                final ListResultBean<WebConfig> list = new ListResultBean<>();
                list.add((WebConfig) crawlingConfigHelper.getCrawlingConfig("W1"));

@Implements(DnsResolver::class)
class ShadowDnsResolver {
  var responder: (Request) -> Unit = {
    it.callback.onAnswer(listOf(), 0)
  }

  data class Request(
    val network: Network?,
    val domain: String,
    val nsType: Int,
    val flags: Int,
    val callback: DnsResolver.Callback<List<InetAddress>>,
  )

  @Implementation
  fun query(
    network: Network?,
    domain: String,

        void callback(CQ query, CF filter);
    }

    @FunctionalInterface
    public interface OperatorCall<CQ extends EsAbstractConditionQuery> {

        void callback(CQ query);
    }

    @FunctionalInterface
    public interface ScoreFunctionCall<CC extends ScoreFunctionCreator<?>> {

        void callback(CC creator);
    }

    @FunctionalInterface

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

 * limitations under the License.
 */
package okhttp.android.testapp

import android.os.Bundle
import androidx.activity.ComponentActivity
import okhttp3.Call
import okhttp3.Callback
import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.Response
import okio.IOException

class MainActivity : ComponentActivity() {

                            },
                        },
                    },
                    "callbacks": {
                        "post_callback": {
                            "/post-callback": {
                                "post": {
                                    "summary": "Post Callback",
                                    "operationId": "baz_post_callback",

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