this.repository = new WorkspaceRepository(key.getContentType(), key);
    }

    public List<WorkspaceReader> getReaders() {
        return readers;
    }

    public void addReader(WorkspaceReader workspaceReader) {
        requireNonNull(workspaceReader, "workspaceReader");
        ArrayList<WorkspaceReader> newReaders = new ArrayList<>(this.readers);
        newReaders.add(workspaceReader);

            afterSessionStart(session);
        } catch (MavenExecutionException e) {
            return addExceptionToResult(result, e);
        }

        try {
            chainedWorkspaceReader.addReader(lookup.lookup(WorkspaceReader.class, ReactorReader.HINT));
        } catch (LookupException e) {
            return addExceptionToResult(result, e);
        }

      MockResponse
        .Builder()
        .addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))
        .addHeader("Expires: " + formatDate(1, TimeUnit.HOURS))
        .code(responseCode)
        .body("ABCDE")
        .addHeader("WWW-Authenticate: challenge")
    when (responseCode) {
      HttpURLConnection.HTTP_PROXY_AUTH -> {
        builder.addHeader("Proxy-Authenticate: Basic realm=\"protected area\"")
      }

  }

  private fun trailersAndCache(protocol: Protocol) {
    enableProtocol(protocol)

    server.enqueue(
      MockResponse
        .Builder()
        .addHeader("h1", "v1")
        .addHeader("Cache-Control: max-age=30")
        .body(protocol, "Hello")
        .trailers(headersOf("t1", "v2"))
        .build(),
    )

    val call1 = client.newCall(Request(server.url("/")))

        originalRequest
          .newBuilder()
          .method("POST", uppercase(originalRequest.body))
          .addHeader("OkHttp-Intercepted", "yep")
          .build(),
      )
    }
    val request =
      Request
        .Builder()
        .url(server.url("/"))
        .addHeader("Original-Header", "foo")
        .method("PUT", "abc".toRequestBody("text/plain".toMediaType()))
        .build()

    builder.header("AZab09~", "AZab09 ~")
    builder.addHeader("AZab09~", "AZab09 ~")
  }

  @Test
  fun emptyNameForbidden() {
    val builder = Request.Builder()
    assertFailsWith<IllegalArgumentException> {
      builder.header("", "Value")
    }
    assertFailsWith<IllegalArgumentException> {
      builder.addHeader("", "Value")
    }
  }

  @Test

        httpResponse.addHeader(ACCESS_CONTROL_ALLOW_ORIGIN, origin);
        httpResponse.addHeader(ACCESS_CONTROL_ALLOW_METHODS, fessConfig.getApiCorsAllowMethods());
        httpResponse.addHeader(ACCESS_CONTROL_ALLOW_HEADERS, fessConfig.getApiCorsAllowHeaders());
        httpResponse.addHeader(ACCESS_CONTROL_MAX_AGE, fessConfig.getApiCorsMaxAge());

    } catch (FileNotFoundException e) {
      return new MockResponse()
          .setStatus("HTTP/1.1 404")
          .addHeader("content-type: text/plain; charset=utf-8")
          .setBody("NOT FOUND: " + path);
    } catch (IOException e) {
      return new MockResponse()
          .setStatus("HTTP/1.1 500")
          .addHeader("content-type: text/plain; charset=utf-8")
          .setBody("SERVER ERROR: " + e);
    }
  }

    return apply { status = "HTTP/1.1 $code $reason" }
  }

  fun clearHeaders() =
    apply {
      headersBuilder = Headers.Builder()
    }

  fun addHeader(header: String) =
    apply {
      headersBuilder.add(header)
    }

  fun addHeader(
    name: String,
    value: Any,
  ) = apply {
    headersBuilder.add(name, value.toString())
  }

  fun addHeaderLenient(
    name: String,

    builder.header("AZab09~", "AZab09 ~")
    builder.addHeader("AZab09~", "AZab09 ~")
  }

  @Test
  fun emptyNameForbidden() {
    val builder = Request.Builder()
    assertFailsWith<IllegalArgumentException> {
      builder.header("", "Value")
    }
    assertFailsWith<IllegalArgumentException> {
      builder.addHeader("", "Value")
    }
  }

  @Test