.code(301)
        .addHeader("Location", url.newBuilder().host("differentdns.com").build())
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .body("unexpected call")
        .build(),
    )
    assertFailsWith<IOException> {
      val response = execute(url)
      response.close()
    }
  }

  /** Not in the certificate SAN.  */
  @Test

      switch (state) {
        case RUNNABLE:
        case BLOCKED:
          Thread.yield();
          break;
        case WAITING:
          return;
        default:
          throw new AssertionError("unexpected state: " + state);
      }
    }
  }

  abstract static class OldAbstractFuture<V> implements ListenableFuture<V> {

    /** Synchronization control for AbstractFutures. */

	}

	if !complete {
		// The method set has unexported methods, so all the
		// implementations are provided by the same package,
		// so the method set can be extended. Instead of recording
		// the full set of names (below), record only that there were
		// unexported methods. (If the interface shrinks, we will notice
		// because a method signature emitted during the last loop

			}

			switch {
			case test.expectedErr == nil:
				if err != nil {
					t.Errorf("error: expected = <nil>, got = %v", err)
				}
			case err == nil:
				t.Errorf("error: expected = %v, got = <nil>", test.expectedErr)
			case test.expectedErr.Error() != err.Error():
				t.Errorf("error: expected = %v, got = %v", test.expectedErr, err)
			}

			if err == nil {

    ExecutionException expected = assertThrows(ExecutionException.class, () -> getDone(future));
    assertThat(expected.getCause()).isEqualTo(exception);

    expected = assertThrows(ExecutionException.class, () -> getDoneFromTimeoutOverload(future));
    assertThat(expected.getCause()).isEqualTo(exception);
  }

    ExecutionException expected = assertThrows(ExecutionException.class, () -> getDone(future));
    assertThat(expected.getCause()).isEqualTo(exception);

    expected = assertThrows(ExecutionException.class, () -> getDoneFromTimeoutOverload(future));
    assertThat(expected.getCause()).isEqualTo(exception);
  }

func healFreshDisk(ctx context.Context, z *erasureServerPools, endpoint Endpoint) error {
	poolIdx, setIdx := endpoint.PoolIdx, endpoint.SetIdx
	disk := getStorageViaEndpoint(endpoint)
	if disk == nil {
		return fmt.Errorf("Unexpected error disk must be initialized by now after formatting: %s", endpoint)
	}

	_, err := disk.DiskInfo(ctx, DiskInfoOptions{})
	if err != nil {
		if errors.Is(err, errDriveIsRoot) {

		if _, ok := err.(*RemoteErr); !ok {
			t.Fatalf("Unexpected error: %v, %T", err, err)
		}
		// Streams should not be able to set up until registered.
		// Thus, the error is a local error.
		_, err = remoteConn.NewStream(t.Context(), handlerTest, []byte(testPayload))
		if !errors.Is(err, ErrUnknownHandler) {
			t.Fatalf("Unexpected error: %v, %T", err, err)
		}
	})
}

        val peekedHeader =
          reader.peekHeader()
            ?: throw ProtocolException("expected a value at $reader")

        val choice =
          choices.firstOrNull { it.matches(peekedHeader) }
            ?: throw ProtocolException(
              "expected a matching choice but was $peekedHeader at $reader",
            )

        return choice to choice.fromDer(reader)
      }

  }

  @Test
  fun clientCloseWith0Fails() {
    assertFailsWith<IllegalArgumentException> {
      client.webSocket!!.close(0, null)
    }.also { expected ->
      assertThat("Code must be in range [1000,5000): 0")
        .isEqualTo(expected.message)
    }
  }

  @Test
  fun afterSocketClosedPingFailsWebSocket() {
    server.source.close()
    client.webSocket!!.pong("Ping!".encodeUtf8())