assertThat(transformation.isVertical()).isFalse();
    assertThat(transformation.isHorizontal()).isFalse();
    assertThat(transformation.slope()).isWithin(ALLOWED_ERROR).of(slope);
    // Note that we cannot test the actual mapping of points, as the results will be unreliable due
    // to loss of precision with this value of the slope.
  }

  public void testMappingWithSlope_maximalSlope() {
    double x1 = 1.2;

    assertThat(transformation.isVertical()).isFalse();
    assertThat(transformation.isHorizontal()).isFalse();
    assertThat(transformation.slope()).isWithin(ALLOWED_ERROR).of(slope);
    // Note that we cannot test the actual mapping of points, as the results will be unreliable due
    // to loss of precision with this value of the slope.
  }

  public void testMappingWithSlope_maximalSlope() {
    double x1 = 1.2;

  public void testBadArguments_plusforspace() {
    // space can be a safe char if plusForSpace is false
    PercentEscaper unused = new PercentEscaper(" ", false);

    // space cannot be a safe char is plusForSpace is true
    String msg = "plusForSpace cannot be specified when space is a 'safe' character";
    IllegalArgumentException expected =
        assertThrows(IllegalArgumentException.class, () -> new PercentEscaper(" ", true));

    }

  override fun peekTrailers(): Headers? {
    if (trailers === TRAILERS_RESPONSE_BODY_TRUNCATED) {
      throw IOException("Trailers cannot be read because the response body was truncated")
    }
    check(state == STATE_READING_RESPONSE_BODY || state == STATE_CLOSED) {
      "Trailers cannot be read because the state is $state"
    }
    return trailers
  }

  override fun flushRequest() {
    socket.sink.flush()

     * Unwrap credentials to a specific type.
     *
     * @param <T> the credential type to unwrap to
     * @param type the class of the credential type to unwrap to
     * @return instance for type, null if the type cannot be unwrapped
     */
    <T extends Credentials> T unwrap(Class<T> type);

    /**
     * Get the domain of the user account.
     * @return the domain the user account is in
     */
    String getUserDomain();

 * options and then retried without them should the attempt fail.
 *
 * ## Connection Reuse
 *
 * Each connection can carry a varying number of streams, depending on the underlying protocol being
 * used. HTTP/1.x connections can carry either zero or one streams. HTTP/2 connections can carry any
 * number of streams, dynamically configured with `SETTINGS_MAX_CONCURRENT_STREAMS`. A connection

import okhttp3.Response;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;

/**
 * Create UNIX domain sockets for MockWebServer and OkHttp and connect 'em together. Note that we
 * cannot do TLS over domain sockets.
 */
public class ClientAndServer {
  public void run() throws Exception {
    File socketFile = new File("/tmp/ClientAndServer.sock");
    socketFile.delete(); // Clean up from previous runs.

  RecordedRequest request3 = server.takeRequest();
  assertEquals("/v1/chat/messages/3", request3.getUrl().encodedPath());

  // Shut down the server. Instances cannot be reused.
  server.close();
}
```

### Kotlin
```kotlin
fun test() {
  // Create a MockWebServer. These are lean enough that you can create a new
  // instance for every unit test.

                                }
                            }
                        }
                    }
                }
            }
        } catch (final IOException e) {
            logger.warn("Cannot load subpackages from {}", basePackage, e);
        }

        subPackages.stream().forEach(protocol -> {
            try {

 * <p>{@code GwtTestSuiteGenerator} expects every {@code DerivedIterator} implementation to provide
 * a one-arg constructor accepting its inner generator as an argument. This requirement enables it
 * to generate source code (since GWT cannot use reflection to generate the suites).
 *
 * @author Chris Povirk
 */
@GwtCompatible
public interface DerivedGenerator {
  TestSubjectGenerator<?> getInnerGenerator();