}

	if !set && value > 0 {
		log.Fatalln("to set a value please specify --set along with --value")
	}

	table := tablewriter.NewWriter(os.Stdout)
	table.SetHeader([]string{"Name", "Value"})
	table.SetAutoWrapText(false)
	table.SetAutoFormatHeaders(true)
	table.SetHeaderAlignment(tablewriter.ALIGN_LEFT)
	table.SetAlignment(tablewriter.ALIGN_LEFT)
	table.SetCenterSeparator("")

        nonNull(request, "request");
        Path path = request.getPath();
        URL url = request.getURL();
        Reader reader = request.getReader();
        InputStream inputStream = request.getInputStream();
        if (path == null && url == null && reader == null && inputStream == null) {

        }

    }

    protected void processHeader(final HttpServletRequest request, final Set<String> roleSet) {

        final String parameter = request.getHeader(headerKey);
        if (logger.isDebugEnabled()) {
            logger.debug("{}:{}", headerKey, parameter);
        }
        if (StringUtil.isNotEmpty(parameter)) {

        .build()
    url = server.url("/")
  }

  @Test
  fun get() {
    assumeNotWindows()
    server.enqueue(
      MockResponse.Builder()
        .body("Hello!")
        .setHeader("Content-Type", PLAIN)
        .build(),
    )
    val response = client.newCall(request().build()).execute()
    assertThat(response.body).isNotNull()
    response.body.bytes()
    logRecorder

    var method: String? = recordedRequest.method
    var path: String? = recordedRequest.path
    var headers: Headers = recordedRequest.headers
    val header: String? = recordedRequest.getHeader("")
    var chunkSizes: List<Int> = recordedRequest.chunkSizes
    var bodySize: Long = recordedRequest.bodySize
    var body: Buffer = recordedRequest.body
    var utf8Body: String = recordedRequest.body.readUtf8()

  }

  @Test @Disabled
  fun mockResponse() {
    val mockResponse = MockResponse()
    var status: String = mockResponse.getStatus()
    var headers: Headers = mockResponse.getHeaders()
    var trailers: Headers = mockResponse.getTrailers()
    var socketPolicy: SocketPolicy = mockResponse.getSocketPolicy()
    var http2ErrorCode: Int = mockResponse.getHttp2ErrorCode()
  }

  @Test @Disabled

    val builder =
      MockResponse.Builder()
        .clearHeaders()
        .addHeader("Cookie: s=square")
        .addHeader("Cookie: a=android")
        .addHeader("Cookies: delicious")
    builder.setHeader("cookie", "r=robot")
    assertThat(headersToList(builder)).containsExactly("Cookies: delicious", "cookie: r=robot")
  }

  @Test
  fun mockResponseSetHeaders() {
    val builder =
      MockResponse.Builder()

    sink: BufferedSink,
    request: RecordedRequest,
    response: MockResponse,
  ) {
    val key = request.headers["Sec-WebSocket-Key"]
    val webSocketResponse =
      response.newBuilder()
        .setHeader("Sec-WebSocket-Accept", WebSocketProtocol.acceptHeader(key!!))
        .build()
    writeHttpResponse(socket, sink, webSocketResponse)

    // Adapt the request and response into our Request and Response domain model.

                return;
            }
        }
        response.contentType(mimeType);
    }

    public String getClientIp(final HttpServletRequest request) {
        final String value = request.getHeader("x-forwarded-for");
        if (StringUtil.isNotBlank(value)) {
            return value;
        }
        return request.getRemoteAddr();
    }

    assertThat(recordedEvents).doesNotContain("DnsEnd")
  }

  @Test
  fun multipleDnsLookupsForSingleCall() {
    server.enqueue(
      MockResponse.Builder()
        .code(301)
        .setHeader("Location", "http://www.fakeurl:" + server.port)
        .build(),
    )
    server.enqueue(MockResponse())
    val dns = FakeDns()
    dns["fakeurl"] = client.dns.lookup(server.hostName)