}

  @Test fun outOfBounds() {
    assertFailsWith<IllegalArgumentException> {
      table.map(-1, Buffer())
    }
    table.map(0, Buffer()) // Lowest legal code point.
    table.map(0x10ffff, Buffer()) // Highest legal code point.
    assertFailsWith<IllegalArgumentException> {
      table.map(0x110000, Buffer())
    }
  }

  @Test fun binarySearchEvenSizedRange() {

      cp >>>= 4;
      dest[4] = upperHexDigits[0x8 | (cp & 0x3)];
      cp >>>= 2;
      dest[2] = upperHexDigits[cp];
      return dest;
    } else if (cp <= 0x10ffff) {
      char[] dest = new char[12];
      // Four byte UTF-8 characters [cp >= 0xffff && cp <= 0x10ffff]
      // Start with "%F-%--%--%--" and fill in the blanks
      dest[0] = '%';
      dest[1] = 'F';
      dest[3] = '%';
      dest[6] = '%';

   * kinds of common human text.
   *
   * @see MaxCodePoint#decode
   */
  @Param({"0x80", "0x90", "0x100", "0x800", "0x10000", "0x10ffff"})
  MaxCodePoint maxCodePoint;

  @Param({"16384"})
  int charCount;

  @Param({"MURMUR3_32", "MURMUR3_128", "SHA1"})
  HashFunctionEnum hashFunctionEnum;

  private String[] strings;

          +
          // Three byte characters
          THREE_BYTE_ROUNDTRIPPABLE_CHARACTERS;

  // 1,048,576 [chars 0x10000L to 0x10FFFF]
  private static final long FOUR_BYTE_ROUNDTRIPPABLE_CHARACTERS = 0x10FFFF - 0x10000L + 1;

  // 289,571,839
  private static final long EXPECTED_FOUR_BYTE_ROUNDTRIPPABLE_COUNT =
      // All one byte characters

      mappings.binarySearch {
        when {
          it.sourceCodePoint1 < codePoint -> -1
          it.sourceCodePoint0 > codePoint -> 1
          else -> 0
        }
      }

    // Code points must be in 0..0x10ffff.
    require(index in mappings.indices) { "unexpected code point: $codePoint" }

    val mapping = mappings[index]
    var result = true

    when (mapping.type) {
      TYPE_IGNORED -> Unit

      val deltaN = i / (codePoints.size + 1)
      if (n > Int.MAX_VALUE - deltaN) return false // Prevent overflow.
      n += deltaN
      i %= (codePoints.size + 1)

      if (n > 0x10ffff) return false // Not a valid code point.

      codePoints.add(i, n)

      i++
    }

    for (codePoint in codePoints) {
      result.writeUtf8CodePoint(codePoint)
    }

    return true

 * <a href="http://www.unicode.org/glossary/#supplementary_code_point">supplementary Unicode code
 * points</a> in the range {@code 0x10000} to {@code 0x10FFFF} which includes the majority of
 * assigned characters, including important CJK characters and emoji.
 *
 * <p>Supplementary characters are <a

0 and 255 inclusive.  Hexadecimal escapes satisfy this condition
by construction. The escapes <code>\u</code> and <code>\U</code>
represent Unicode code points so within them some values are illegal,
in particular those above <code>0x10FFFF</code> and surrogate halves.
</p>

<p>
After a backslash, certain single-character escapes represent special values:
</p>

<pre class="grammar">
\a   U+0007 alert or bell
\b   U+0008 backspace