*/
  public static void write(byte[] from, File to) throws IOException {
    asByteSink(to).write(from);
  }

  /**
   * Writes a character sequence (such as a string) to a file using the given character set.
   *
   * @param from the character sequence to write
   * @param to the destination file
   * @param charset the charset used to encode the output stream; see {@link StandardCharsets} for

 * When making TLS connections with multiple [connection specs](https://square.github.io/okhttp/4.x/okhttp/okhttp3/-connection-spec/), these are attempted in sequence until the TLS handshake succeeds.

### [Connections](https://square.github.io/okhttp/4.x/okhttp/okhttp3/-connection/)

When you request a URL with OkHttp, here's what it does:

		return "", d.mkError(ErrSyntax, "in unicode escape sequence")
	}

	// check for proceeding surrogate pair
	c = d.next()
	if !utf16.IsSurrogate(r) || c != '\\' {
		d.scratch.addRune(r)
		goto scan
	}
	if c = d.next(); c != 'u' {
		d.scratch.addRune(r)
		goto scan_esc
	}

	r2 := d.u4()
	if r2 < 0 {
		return "", d.mkError(ErrSyntax, "in unicode escape sequence")
	}

	// write surrogate pair

 * (like 0030..0039).
 *
 * The second element on each line is a mapping type, like `valid` or `mapped`.
 *
 * For lines that contain a mapping target, the next thing is a sequence of hex code points (like
 * 0031 2044 0034).
 *
 * All other data is ignored.
 */
fun BufferedSource.readPlainTextIdnaMappingTable(): SimpleIdnaMappingTable {
  val mappedTo = Buffer()

   * i, i + target.length)} contains exactly the same elements as {@code target}.
   *
   * @param array the array to search for the sequence {@code target}
   * @param target the array to search for as a sub-sequence of {@code array}
   */
  public static int indexOf(boolean[] array, boolean[] target) {
    checkNotNull(array, "array");
    checkNotNull(target, "target");

   * i, i + target.length)} contains exactly the same elements as {@code target}.
   *
   * @param array the array to search for the sequence {@code target}
   * @param target the array to search for as a sub-sequence of {@code array}
   */
  public static int indexOf(boolean[] array, boolean[] target) {
    checkNotNull(array, "array");
    checkNotNull(target, "target");

        ShareEnumIterator it = new ShareEnumIterator(parent, entries.iterator(), null);

        // hasNext/next sequence over two elements
        assertTrue(it.hasNext(), "Expected first element available");
        SmbResource r1 = it.next();
        assertNotNull(r1);

 * until [nextPart] returns null. After calling [nextPart] any preceding parts should not be read.
 *
 * Typical use loops over the parts in sequence:
 *
 * ```kotlin
 * val response: Response = call.execute()
 * val multipartReader = MultipartReader(response.body!!)
 *
 * multipartReader.use {
 *   while (true) {

  protected Table<String, Integer, C> table;

  /**
   * Creates a table with the specified data.
   *
   * @param data the table data, repeating the sequence row key, column key, value once per mapping
   * @throws IllegalArgumentException if the size of {@code data} isn't a multiple of 3
   * @throws ClassCastException if a data element has the wrong type
   */

    }
  }

  /**
   * Artificially stall until manually resumed by the test thread with [runTasks]. Use this to
   * simulate races in tasks that doesn't have a deterministic sequence.
   */
  fun yield() {
    taskRunner.assertLockNotHeld()
    taskRunner.withLock {
      yieldUntil()
    }
  }

  /** Process the queue until [condition] returns true. */