fun createFactory(callFactory: Call.Factory): EventSource.Factory {
    return EventSource.Factory { request, listener ->
      val actualRequest =
        if (request.header("Accept") == null) {
          request.newBuilder().addHeader("Accept", "text/event-stream").build()
        } else {
          request
        }

      RealEventSource(actualRequest, listener).apply {
        connect(callFactory)
      }
    }
  }

  @JvmStatic

    var headers: Headers = mockResponse.headers
    var trailers: Headers = mockResponse.trailers
    mockResponse = mockResponse.clearHeaders()
    mockResponse = mockResponse.addHeader("")
    mockResponse = mockResponse.addHeader("", "")
    mockResponse = mockResponse.addHeaderLenient("", Any())
    mockResponse = mockResponse.setHeader("", Any())
    mockResponse.headers = headersOf()
    mockResponse.trailers = headersOf()

    val header =
      when (response.code) {
        407 -> "Proxy-Authorization"
        else -> "Authorization"
      }
    return response.request.newBuilder()
      .addHeader(header, credential)
      .build()
  }

  private fun schemeMatches(response: Response): Boolean {
    if (scheme == null) return true
    return response.challenges().any { it.scheme.equals(scheme, ignoreCase = true) }

	return testObject{
		name:      name,
		namespace: namespace,
		version:   version,
	}
}

func TestWriter(t *testing.T) {
	got := &bytes.Buffer{}
	w := NewStyleWriter(got)
	w.AddHeader("NAME", "NAMESPACE", "VERSION")
	w.SetAddRowFunc(func(obj interface{}) Row {
		o := obj.(testObject)
		return Row{
			Cells: []Cell{
				NewCell(o.name),
				NewCell(o.namespace, color.FgGreen),

        'default.vcxproj.filters'
    }

    def addSource(File sourceFile) {
        sources.appendNode("ClCompile", [Include: toPath(sourceFile)]).appendNode('Filter', 'Source Files')
    }

    def addHeader(File headerFile) {
        headers.appendNode("ClInclude", [Include: toPath(headerFile)]).appendNode('Filter', 'Header Files')
    }

    def getFilters() {

        this.cookie = cookie
        this.attributes = attributes
    }

    @Override
    void handle(HttpServletRequest request, HttpServletResponse response) {
        response.addHeader("Set-Cookie", "cookie_name=$cookie; $attributes")
        String message = "Cookie sent"
        response.setContentLength(message.bytes.length)
        response.setContentType("text/html")

        registration.add(HttpBuildCacheRequestCustomizer.class, request -> request.addHeader("X-Gradle-Version", GradleVersion.current().getVersion()));
    }

You can set a custom body with a string, input stream or byte array. Also
add headers with a fluent builder API.

```java
MockResponse response = new MockResponse()
    .addHeader("Content-Type", "application/json; charset=utf-8")
    .addHeader("Cache-Control", "no-cache")
    .setBody("{}");
```

MockResponse can be used to simulate a slow network. This is useful for
testing timeouts and interactive testing.

```java

            }
            catch ( SmbAuthException sae ) {
                response.setHeader("WWW-Authenticate", "NTLM");
                if ( offerBasic ) {
                    response.addHeader("WWW-Authenticate", "Basic realm=\"" + this.realm + "\"");
                }
                response.setHeader("Connection", "close");
                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);

                SmbSession.logon(dc, ntlm);
            } catch (SmbAuthException sae) {
                response.setHeader("WWW-Authenticate", "NTLM");
                if (offerBasic) {
                    response.addHeader("WWW-Authenticate", "Basic realm=\"" +
                            realm + "\"");
                }
                response.setHeader("Connection", "close");