@NullUnmarked
public class ListenerCallQueueTest extends TestCase {

  private static final ListenerCallQueue.Event<Object> THROWING_EVENT =
      new ListenerCallQueue.Event<Object>() {
        @Override
        public void call(Object object) {
          throw new RuntimeException();
        }

        @Override
        public String toString() {
          return "throwing()";
        }
      };

# Debugging { #debugging }

You can connect the debugger in your editor, for example with Visual Studio Code or PyCharm.

## Call `uvicorn` { #call-uvicorn }

In your FastAPI application, import and run `uvicorn` directly:

{* ../../docs_src/debugging/tutorial001_py39.py hl[1,15] *}

### About `__name__ == "__main__"` { #about-name-main }

When you want to call an `async def` function, you have to "await" it. So, this won't work:

```Python
# This won't work, because get_burgers was defined with: async def
burgers = get_burgers(2)
```

---

TF_CAPI_EXPORT extern void TF_CloseSession(TF_Session*, TF_Status* status);

// Destroy a session object.
//
// Even if error information is recorded in *status, this call discards all
// local resources associated with the session.  The session may not be used
// during or after this call (and the session drops its reference to the
// corresponding graph).
TF_CAPI_EXPORT extern void TF_DeleteSession(TF_Session*, TF_Status* status);

            slf4jConfiguration.setRootLoggerLevel(loggerLevel);
        } else {
            // fall back to default log level specified in conf
            loggerLevel = Slf4jConfiguration.Level.INFO; // default for display purposes
            // Do NOT call setRootLoggerLevel - this is the fix!
        }

        // Verify that setRootLoggerLevel was not called

    // it.
    executeListener(runnable, executor);
  }

  /**
   * Runs this execution list, executing all existing pairs in the order they were added. However,
   * note that listeners added after this point may be executed before those previously added, and
   * note that the execution order of all listeners is ultimately chosen by the implementations of
   * the supplied executors.
   *

 */

package okhttp3.modules;

import okhttp3.Call;
import okhttp3.HttpUrl;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.logging.HttpLoggingInterceptor;
import okhttp3.logging.LoggingEventListener;

/**
 * Just checking compilation works
 */
public class OkHttpCaller {
  public static Call callOkHttp(HttpUrl url) {
    OkHttpClient client = new OkHttpClient
      .Builder()

    address: Address,
    routeDatabase: RouteDatabase = this.routeDatabase,
    fastFallback: Boolean = false,
    call: RealCall = this.call,
  ): RouteSelector =
    RouteSelector(
      address = address,
      routeDatabase = routeDatabase,
      fastFallback = fastFallback,
      call = call,
    )

  companion object {
    private const val PROXY_A_PORT = 1001
    private const val PROXY_A_HOST = "proxya"

    }

    @Test
    void testGetUrlHandler() {
        // Test getUrlHandler() method
        // First call should create a new Handler
        URLStreamHandler handler1 = cifsContextWrapper.getUrlHandler();
        assertNotNull(handler1);
        assertTrue(handler1 instanceof Handler);

        // Second call should return the same instance
        URLStreamHandler handler2 = cifsContextWrapper.getUrlHandler();

   * given executor at the first call to {@code addListener}. The task must be started by the
   * executor promptly, or else the returned {@code ListenableFuture} may fail to work. The task's
   * execution consists of blocking until the input future is {@linkplain Future#isDone() done}, so
   * each call to this method may claim and hold a thread for an arbitrary length of time. Use of