class OkHttpClientTest {
  @RegisterExtension
  var platform = PlatformRule()

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  private var server: MockWebServer? = null

  @BeforeEach fun setUp(server: MockWebServer?) {
    this.server = server
  }

  @AfterEach fun tearDown() {
    ProxySelector.setDefault(DEFAULT_PROXY_SELECTOR)
    CookieManager.setDefault(DEFAULT_COOKIE_HANDLER)

  private static final ImmutableList<String> SPLIT_LINES =
      ImmutableList.of("foo", "bar", "baz", "something");

  private TestCharSource source;

  @Override
  public void setUp() {
    source = new TestCharSource(STRING);
  }

  public void testOpenBufferedStream() throws IOException {
    BufferedReader reader = source.openBufferedStream();
    assertTrue(source.wasStreamOpened());

### Testing an example with awscli tool

> Use the same username and password created in the previous steps.

```
[foobar]
region = us-east-1
aws_access_key_id = foobar
aws_secret_access_key = foo12345
```

    clientTestRule.newClientBuilder()
      .dns { throw UnknownHostException() }
      .dispatcher(dispatcher)
      .eventListenerFactory(clientTestRule.wrap(listener))
      .build()

  @BeforeEach
  fun setUp() {
    dispatcher.maxRequests = 20
    dispatcher.maxRequestsPerHost = 10
    listener.forbidLock(dispatcher)
  }

  @Test
  fun maxRequestsZero() {
    assertFailsWith<IllegalArgumentException> {

        saveToken();
        return asIndexHtml();
    }

    private HtmlResponse asIndexHtml() {
        return asHtml(path_AdminMaintenance_AdminMaintenanceJsp).useForm(ActionForm.class, op -> op.setup(f -> {
            f.replaceAliases = Constants.ON;
            f.resetDictionaries = null;
        }));
    }

    @Execute
    @Secured({ ROLE })

                    getTestUser(),
                    getTestUserPassword(),
                    getTestUserDomain());
            }
        }
        catch ( SmbException e ) {
            // no setup to resolve hostname if netbios is used
            if ( e.getCause() instanceof UnknownHostException ) {
                Assume.assumeTrue(false);
            }
            throw e;
        }
    }

    ArtifactRepositoryLayout repoLayout;

    @Inject
    PlexusContainer container;

    public PlexusContainer getContainer() {
        return container;
    }

    @BeforeEach
    public void setUp() throws Exception {
        RepositorySystemSession repoSession = initRepoSession();
        MavenSession session = new MavenSession(

                    delegate.setupRealm(classRealm, request);
                } catch (Exception e) {
                    logger.error(
                            delegate.getClass().getName() + " failed to setup class realm " + classRealm + ": "
                                    + e.getMessage(),
                            e);
                }
            }
        }
    }

Handlers should remain backwards compatible. If a breaking API change is required, a new handler ID should be created.

## Setup & Configuration

A **Manager** is used to manage all incoming and outgoing connections to a server.

On startup all remote servers must be specified. 
From that individual connections will be spawned to each remote server, 

      this.uriHost = ******@****.***t
      this.uriPort = ******@****.***t
    }

  private lateinit var call: RealCall
  private val routeDatabase = RouteDatabase()

  @BeforeEach fun setUp() {
    call =
      clientTestRule.newClient().newCall(
        Request.Builder()
          .url("https://$uriHost:$uriPort/")
          .build(),
      ) as RealCall
  }

  @AfterEach fun tearDown() {