statusFile := fmt.Sprintf("/proc/self/task/%d/status", tid)
	fd, err := syscall.Open(statusFile, syscall.O_RDONLY, 0)
	if errno, ok := err.(syscall.Errno); ok {
		if errno == syscall.ENOENT || errno == syscall.ESRCH {
			return false, true, nil
		}
	}
	if err != nil {
		return false, false, err
	}
	status, err := io.ReadAll(os.NewFile(uintptr(fd), statusFile))
	if err != nil {

          }
"""
        setMetadataSupplierClass('MP')

        when:
        def statusFile = temporaryFolder.createFile("versions.status")
        statusFile << '''group:projectA:1.1;release
group:projectA:1.2;release
group:projectB:1.1;release
group:projectB:2.2;integration
'''
        server.expectGet("/repo/status.txt", statusFile)
        repositoryInteractions {
            'group:projectA' {

      val codeStart: Int
      val protocol: Protocol
      if (statusLine.startsWith("HTTP/1.")) {
        if (statusLine.length < 9 || statusLine[8] != ' ') {
          throw ProtocolException("Unexpected status line: $statusLine")
        }
        val httpMinorVersion = statusLine[7] - '0'
        codeStart = 9
        protocol =
          when (httpMinorVersion) {

    val code = 503
    val statusLine = parse("HTTP/1.$version $code")
    assertThat(statusLine.message).isEqualTo("")
    assertThat(statusLine.protocol).isEqualTo(Protocol.HTTP_1_1)
    assertThat(statusLine.code).isEqualTo(code)
  }

  // https://github.com/square/okhttp/issues/386
  @Test
  fun shoutcast() {
    val statusLine = parse("ICY 200 OK")
    assertThat(statusLine.message).isEqualTo("OK")

        1 * response.close()
    }

    private CloseableHttpResponse mockHttpResponse() {
        def response = Mock(CloseableHttpResponse)
        def statusLine = Mock(StatusLine)
        statusLine.getStatusCode() >> 200
        response.getStatusLine() >> statusLine
        response
    }

        try (HttpClientResponse response = httpClientHelper.performHttpRequest(httpGet)) {
            StatusLine statusLine = response.getStatusLine();
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("Response for GET {}: {}", safeUri(uri), statusLine);
            }
            int statusCode = statusLine.getStatusCode();
            if (isHttpSuccess(statusCode)) {
                reader.readFrom(response.getContent());

        buildFile <<
                """
class StatusRule implements ComponentMetadataRule {
    public void execute(ComponentMetadataContext context) {
        assert context.details.status == "silver"
        context.details.statusScheme = ["gold", "silver", "bronze"]
    }
}
dependencies {
    components {
        all(StatusRule)
    }
}
"""

        expect:
        succeeds 'resolve'

      protocol: Protocol,
    ): Response.Builder {
      var statusLine: StatusLine? = null
      val headersBuilder = Headers.Builder()
      for (i in 0 until headerBlock.size) {
        val name = headerBlock.name(i)
        val value = headerBlock.value(i)
        if (name == RESPONSE_STATUS_UTF8) {
          statusLine = StatusLine.parse("HTTP/1.1 $value")
        } else if (name !in HTTP_2_SKIPPED_RESPONSE_HEADERS) {

        url "${ivyRepo.uri}"
    }
}

class StatusRule implements ComponentMetadataRule {
    public void execute(ComponentMetadataContext context) {
        context.details.statusScheme = ["bronze", "silver", "gold", "platin"]
    }
}

configurations { compile }
dependencies {
    compile 'org.test:projectA:latest.$status'
    components {
        all(StatusRule)
    }
}

task retrieve(type: Sync) {

    ) {
      "state: $state"
    }

    try {
      val statusLine = StatusLine.parse(headersReader.readLine())

      val responseBuilder =
        Response.Builder()
          .protocol(statusLine.protocol)
          .code(statusLine.code)
          .message(statusLine.message)
          .headers(headersReader.readHeaders())
          .trailers { error("trailers not available") }