private val handshake: Handshake?,
  private val protocol: Protocol,
  private val socket: BufferedSocket,
  private val pingIntervalMillis: Int,
  internal val connectionListener: ConnectionListener,
) : Http2Connection.Listener(),
  Connection,
  ExchangeCodec.Carrier,
  Lockable {
  private var http2Connection: Http2Connection? = null

  // These properties are guarded by `this`.

  /**

    listener.removeUpToEvent(ConnectionAcquired::class.java)
    listener.removeUpToEvent(ResponseFailed::class.java)
    listener.removeUpToEvent(ConnectionReleased::class.java)
    listener.removeUpToEvent(ConnectionAcquired::class.java)
    listener.removeUpToEvent(ConnectionReleased::class.java)
    listener.removeUpToEvent(CallEnd::class.java)
  }

  @Test
  fun recoverWhenRetryOnConnectionFailureIsTrue_HTTP2() {

# See the License for the specific language governing permissions and
# limitations under the License.
#

#
# Simple shell script for launching CI jobs using the @bot-gradle GitHub comment listener.
# Uses the [hub](https://hub.github.com/) CLI command to issue API requests to GitHub.
# This script must be executed from the branch associated with the PR to issue the command on.
#

PR_NUMBER=$(hub pr show -f '%I')

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

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

      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.
   *

    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,

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

        boolean shutdownListenerAdded = false;

        @Override
        public void addShutdownListener(ShutdownListener listener) {
            shutdownListenerAdded = true;
            // Optionally execute the listener to test its behavior
            listener.onShutdown();
        }

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