) {
    if (byteCount < 0L || byteCount > source.size) {
      throw IndexOutOfBoundsException()
    }
    var mutablePos = pos
    var mutableByteCount = byteCount

    while (mutableByteCount > 0L) {
      val bytesWritten = fileChannel.transferFrom(source, mutablePos, mutableByteCount)
      mutablePos += bytesWritten
      mutableByteCount -= bytesWritten
    }
  }

  /**

  tag: T?,
) = apply {
  if (tag == null) {
    if (tags.isNotEmpty()) {
      (tags as MutableMap).remove(type)
    }
  } else {
    val mutableTags: MutableMap<KClass<*>, Any> =
      when {
        tags.isEmpty() -> mutableMapOf<KClass<*>, Any>().also { tags = it }
        else -> tags as MutableMap<KClass<*>, Any>
      }
    mutableTags[type] = tag
  }
}

import assertk.assertThat
import assertk.assertions.containsExactly
import java.net.InetAddress
import java.net.UnknownHostException
import okio.Buffer

class FakeDns : Dns {
  private val hostAddresses: MutableMap<String, List<InetAddress>> = mutableMapOf()
  private val requestedHosts: MutableList<String> = mutableListOf()
  private var nextAddress = 0xff000064L // 255.0.0.100 in IPv4; ::ff00:64 in IPv6.

  // Another renaming of local device
  const string second_name = "def";
  server_def.set_job_name(second_name);
  server_def.mutable_cluster()->mutable_job(0)->set_name(second_name);
  (*server_def.mutable_cluster()->mutable_job(0)->mutable_tasks())[0] =
      absl::StrCat(second_name, ":",
                   tensorflow::testing::PickUnusedPortOrDie());

  serialized = server_def.SerializeAsString();

  tensorflow::ServerDef server_def_copy = server_def;
  tensorflow::ClusterDef* cluster_def = server_def_copy.mutable_cluster();
  tensorflow::JobDef* job_def = cluster_def->mutable_job(0);
  const int port = tensorflow::testing::PickUnusedPortOrDie();
  job_def->mutable_tasks()->at(task_index) =
      tensorflow::strings::StrCat("localhost:", port);
  return server_def_copy;
}

    return object : CookieHandler() {
      override fun put(
        uri: URI?,
        responseHeaders: MutableMap<String, MutableList<String>>?,
      ) = TODO()

      override fun get(
        uri: URI?,
        requestHeaders: MutableMap<String, MutableList<String>>?,
      ): MutableMap<String, MutableList<String>> = TODO()
    }
  }

  private fun newInterceptorChain(): Interceptor.Chain {

/**
 * Tests how each code point is encoded and decoded in the context of each URL component.
 *
 * This supports [HttpUrlTest].
 */
class UrlComponentEncodingTester private constructor() {
  private val encodings: MutableMap<Int, Encoding> = LinkedHashMap()

  private fun allAscii(encoding: Encoding) =
    apply {
      for (i in 0..127) {
        encodings[i] = encoding
      }
    }

  fun override(
    encoding: Encoding,

  server_def.set_job_name("worker");
  server_def.set_task_index(0);
  tensorflow::ClusterDef* cluster_def = server_def.mutable_cluster();
  tensorflow::JobDef* job_def = cluster_def->mutable_job(0);
  int worker_port = tensorflow::testing::PickUnusedPortOrDie();
  job_def->mutable_tasks()->at(0) =
      tensorflow::strings::StrCat("localhost:", worker_port);
  serialized = server_def.SerializeAsString();

  SetOpAttrValueScalar(ctx, op, i_list_values, "strides", status);

  tensorflow::AttrValue padding_value;
  *padding_value.mutable_s() = "VALID";
  tensorflow::SetOpAttrValueScalar(ctx, op, padding_value, "padding", status);

  tensorflow::AttrValue data_format_value;
  *data_format_value.mutable_s() = "NHWC";
  tensorflow::SetOpAttrValueScalar(ctx, op, data_format_value, "data_format",
                                   status);