return ticker;
    }
    return recordsTime ? Ticker.systemTicker() : NULL_TICKER;
  }

  /**
   * Specifies a listener instance that caches should notify each time an entry is removed for any
   * {@linkplain RemovalCause reason}. Each cache created by this builder will invoke this listener
   * as part of the routine maintenance described in the class documentation above.
   *

        return RESULT_DATA;
      } else {
        throw WRAPPED_EXCEPTION;
      }
    }
  }

  public void testFutureGetThrowsFunctionException() throws Exception {
    inputFuture.set(EXCEPTION_DATA);
    listener.assertException(WRAPPED_EXCEPTION);
  }

    serverListener.assertClosed(1000, "goodbye")
  }

  @Test
  fun webSocketsDontTriggerEventListener() {
    val listener = RecordingEventListener()
    client =
      client
        .newBuilder()
        .eventListenerFactory(clientTestRule.wrap(listener))
        .build()
    webServer.enqueue(
      MockResponse
        .Builder()
        .webSocketUpgrade(serverListener)

    FakeTicker ticker = new FakeTicker();
    QueuingRemovalListener<Integer, Integer> listener =
        TestingRemovalListeners.queuingRemovalListener();
    Cache<Integer, Integer> cache =
        CacheBuilder.newBuilder()
            .expireAfterAccess(1, MINUTES)
            .removalListener(listener)
            .ticker(ticker)
            .build();
    cache.put(1, 1);
    ticker.advance(10, MINUTES);

 * limitations under the License.
 */
package okhttp3.internal.connection

import okhttp3.Call
import okhttp3.Connection
import okhttp3.Route
import okio.IOException

/**
 * Listener for connection events. Extend this class to monitor the new connections and closes.
 *
 * All event methods must execute fast, without external locking, cannot throw exceptions,

 * [RFC 2817][1]. The HTTP CONNECT request that creates this tunnel connection is special: it
 * does not participate in any [interceptors][Interceptor] or [event listeners][EventListener]. It
 * doesn't include the motivating request's HTTP headers or even its full URL; only the target
 * server's hostname is sent to the proxy.
 *

scrollParents.push(target);\n}\n\n/**\n * Setup needed event listeners used to update the popper position\n * @method\n * @memberof Popper.Utils\n * @private\n */\nexport default function setupEventListeners(\n  reference,\n  options,\n  state,\n  updateBound\n) {\n  // Resize event listener on window\n  state.updateBound = updateBound;\n  getWindow(reference).addEventListener('resize', state.updateBound, { passive: true });\n\n  // Scroll event listener on scroll parents\n  const scrollElement = getScrol...

        JobExecutor mockJobExecutor = new JobExecutor() {
            @Override
            public void addShutdownListener(ShutdownListener listener) {
                shutdownListeners.add(listener);
            }

            @Override
            public Object execute(String scriptType, String script) {
                return null;
            }
        };

TF_CAPI_EXPORT extern void TF_DeleteServer(TF_Server* server);

// Register a listener method that processes printed messages.
//
// If any listeners are registered, the print operator will call all listeners
// with the printed messages and immediately return without writing to the
// logs.
TF_CAPI_EXPORT extern void TF_RegisterLogListener(
    void (*listener)(const char*));

    pushObserver: PushObserver = IGNORE,
    listener: Http2Connection.Listener = Http2Connection.Listener.REFUSE_INCOMING_STREAMS,
  ): Http2Connection {
    val connection =
      Http2Connection
        .Builder(true, TaskRunner.INSTANCE)
        .socket(peer.openSocket().asBufferedSocket(), "peer")
        .pushObserver(pushObserver)
        .listener(listener)
        .build()