verify(mockChannelManager, atLeast(1)).establishReplacementChannel();
    }

    @Test
    void testShutdown() {
        failover.shutdown();

        // Should not throw any exceptions
        assertDoesNotThrow(() -> failover.shutdown());
    }

    @Test
    void testConcurrentFailureHandling() throws InterruptedException {
        IOException error = new IOException("Connection failed");

  @Throws(InterruptedException::class)
  abstract fun dispatch(request: RecordedRequest): MockResponse

  open fun peek(): MockResponse = MockResponse().apply { this.socketPolicy = SocketPolicy.KEEP_OPEN }

  open fun shutdown() {}

        .url("http://publicobject.com/helloworld.txt")
        .build();

    try (Response response = client.newCall(request).execute()) {
      System.out.println(response.body().string());
    }

    server.shutdown();
    socketFile.delete();
  }

  public static void main(String... args) throws Exception {
    new ClientAndServer().run();
  }

          this.writer = null
          taskQueue.execute("$name writer close", cancelable = false) {
            writerToClose.closeQuietly()
          }
        }

        this.taskQueue.shutdown()
      }

      sendOnClosed = !failed && writer == null && receivedCloseCode != -1
    }

    if (sendOnClosed) {
      listener.onClosed(this, code, reason!!)
    }

      queue.enqueue(countDownEvent(latch));
      assertEquals(0, counters.size());
      queue.dispatch();
      latch.await();
      assertEquals(multiset(listener, 4), counters);
    } finally {
      service.shutdown();
    }
  }

  public void testEnqueueAndDispatch_multithreaded_withThrowingRunnable()
      throws InterruptedException {
    Object listener = new Object();

      queue.enqueue(countDownEvent(latch));
      assertEquals(0, counters.size());
      queue.dispatch();
      latch.await();
      assertEquals(multiset(listener, 4), counters);
    } finally {
      service.shutdown();
    }
  }

  public void testEnqueueAndDispatch_multithreaded_withThrowingRunnable()
      throws InterruptedException {
    Object listener = new Object();

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.http2

import java.io.IOException

/**
 * Thrown when an HTTP/2 connection is shutdown (either explicitly or if the peer has sent a GOAWAY
 * frame) and an attempt is made to use the connection.
 */

        } catch (Exception e) {
            log.warn("Error during witness client shutdown", e);
        }

        // Shutdown scheduler
        scheduler.shutdown();

        // Close RPC client
        if (rpcClient != null) {
            rpcClient.close();
        }
    }

    /**

    protected String filterPathEncoding;

    /** An array of supported language codes. */
    protected String[] supportedLanguages;

    /** A list of shutdown hooks to be executed on system shutdown. */
    protected List<Runnable> shutdownHookList = new ArrayList<>();

    /** The previous state of the cluster. */
    protected AtomicInteger previousClusterState = new AtomicInteger(0);

  override fun peek(): MockResponse = throw UnsupportedOperationException("unexpected call")

  fun enqueueResponse(response: MockResponse) {
    delegate.enqueue(response.wrap())
  }

  override fun shutdown() {
    delegate.close()
  }

  fun setFailFast(failFast: Boolean) {
    delegate.setFailFast(failFast)
  }

  fun setFailFast(failFastResponse: MockResponse?) {