connection!!.idleAtNs -= IDLE_CONNECTION_HEALTHY_NS
    Thread.sleep(250)

    val requestB =
      Request(
        url = server.url("/"),
        body = "b".toRequestBody("text/plain".toMediaType()),
      )
    val responseB = client.newCall(requestB).execute()
    assertThat(responseB.body.string()).isEqualTo("b")
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(0)
  }

import com.google.common.annotations.J2ktIncompatible;
import com.google.common.primitives.Doubles;

/**
 * A mutable object which accumulates paired double values (e.g. points on a plane) and tracks some
 * basic statistics over all the values added so far. This class is not thread safe.
 *
 * @author Pete Gillin
 * @since 20.0
 */
@J2ktIncompatible
@GwtIncompatible

    body.byteStream().close()
    assertThat(closed.get()).isTrue()
  }

  @Test
  fun unicodeTextWithUnsupportedEncoding() {
    val text = "eile oli oliiviõli"
    val body = text.toResponseBody("text/plain; charset=unknown".toMediaType())
    assertThat(body.string()).isEqualTo(text)
  }

  companion object {
    @JvmOverloads
    fun body(
      hex: String,
      charset: String? = null,

        } catch (final IllegalArgumentException ex) {
            return null;
        }
    }

    /**
     * Converts the pattern string to a plain pattern string without delimiters.
     *
     * @param pattern
     *            The pattern string.
     * @return The plain pattern string without delimiters.
     */
    protected static String toPlainPattern(final String pattern) {

        goodCertificate.certificate,
      )
    server.useHttps(socketFactory)
    server.enqueue(
      MockResponse
        .Builder()
        .body("abc")
        .addHeader("Content-Type: text/plain")
        .build(),
    )

    // Make a request from client to server. It should succeed certificate checks (unfortunately the
    // rogue CA is trusted) but it should fail certificate pinning.
    val request =

	default:
		defer updateOSMetrics(osMetricOpenFileR, name)(err)
	}
	return os.OpenFile(name, flag, perm)
}

// Access captures time taken to call syscall.Access()
// on windows, plan9 and solaris syscall.Access uses
// os.Lstat()
func Access(name string) (err error) {
	defer updateOSMetrics(osMetricAccess, name)(err)
	return access(name)
}

// Open captures time taken to call os.Open

	uploadID := ""
	if len(params) >= 1 {
		bucket = params[0]
	}
	if len(params) == 2 {
		object = params[1]
	}
	if len(params) == 3 {
		uploadID = params[2]
	}

	// in some cases just a plain error is being returned
	switch err.Error() {
	case "storage: bucket doesn't exist":
		err = BucketNotFound{
			Bucket: bucket,
		}
		return err
	case "storage: object doesn't exist":
		if uploadID != "" {

      try {
        ProviderInstaller.installIfNeeded(InstrumentationRegistry.getInstrumentation().targetContext)
      } catch (gpsnae: GooglePlayServicesNotAvailableException) {
        throw TestAbortedException("Google Play Services not available", gpsnae)
      }

      val request = Request.Builder().url("https://facebook.com/robots.txt").build()

      var socketClass: String? = null

        .addHeader("Content-Type: text/plain")
        .addHeader("Last-Modified: " + formatDate(-2, TimeUnit.HOURS))
        .addHeader("Expires: " + formatDate(-1, TimeUnit.HOURS))
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .code(HttpURLConnection.HTTP_NOT_MODIFIED)
        .addHeader("Content-Type: text/plain")
        .addHeader("Content-Encoding: gzip")

    */
    int NTLMSSP_NEGOTIATE_SEAL = 0x00000020;

    /**
    * Indicates datagram authentication.
    */
    int NTLMSSP_NEGOTIATE_DATAGRAM_STYLE = 0x00000040;

    /**
    * Indicates that the LAN Manager session key should be used for
    * signing and sealing authenticated communication.
    */
    int NTLMSSP_NEGOTIATE_LM_KEY = 0x00000080;

    /**
     * Indicates support for NetWare authentication.
     */