+
          // 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

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

      }
    }

    // Test that 0xFFFE and 0xFFFF are replaced with 0xFFFD
    assertEscaping(xmlEscaper, "\uFFFD", '\uFFFE');
    assertEscaping(xmlEscaper, "\uFFFD", '\uFFFF');

    assertWithMessage("0xFFFE is forbidden and should be replaced during escaping")
        .that(xmlEscaper.escape("[\ufffe]"))
        .isEqualTo("[\uFFFD]");
    assertWithMessage("0xFFFF is forbidden and should be replaced during escaping")

    assertThat(escaper.escape("The Quick Brown Fox")).isEqualTo("The Quick Brown Fox");
  }

  public void testBuilderInitialStateNoneUnsafe() {
    // No characters are unsafe by default (safeMin == 0, safeMax == 0xFFFF).
    Escaper escaper = Escapers.builder().setUnsafeReplacement("X").build();
    assertThat(escaper.escape("\0\uFFFF")).isEqualTo("\0\uFFFF");
  }

  public void testBuilderRetainsState() {

      }
    }

    // Test that 0xFFFE and 0xFFFF are replaced with 0xFFFD
    assertEscaping(xmlEscaper, "\uFFFD", '\uFFFE');
    assertEscaping(xmlEscaper, "\uFFFD", '\uFFFF');

    assertWithMessage("0xFFFE is forbidden and should be replaced during escaping")
        .that(xmlEscaper.escape("[\ufffe]"))
        .isEqualTo("[\uFFFD]");
    assertWithMessage("0xFFFF is forbidden and should be replaced during escaping")

    // we can get away with i++ because the whole point of this method is to return false if we find
    // a code point that doesn't fit in a char.
    for (int i = 0; i < string.length(); i++) {
      if (string.codePointAt(i) > 0xffff) {
        return false;
      }
    }
    return true;
  }

  @SuppressWarnings("deprecation")
  public void testSimpleStringUtf8() {
    assertEquals(

  }

  private static long remix(long h) {
    h ^= h >>> 41;
    h *= 949921979;
    return h;
  }

  private static byte getChar(long h) {
    return (byte) ('a' + ((h & 0xfffff) % 26));
  }

    assertEquals(0x000066, (int) webSafeColors.get(2));
    assertEquals(0x003300, (int) webSafeColors.get(6));
    ImmutableList<Integer> addedColor = webSafeColorsBuilder.add(0x00BFFF).build();
    assertEquals(
        "Modifying the builder should not have changed any already built sets",
        216,
        webSafeColors.size());

      checkArgument(
          (port >= 0) && (port <= 0xffff), "port '%s' is out of range (0 <= port <= 0xffff)", port);
      checkArgument(
          (flags >= 0) && (flags <= 0xffff),
          "flags '%s' is out of range (0 <= flags <= 0xffff)",
          flags);

      this.server = MoreObjects.firstNonNull(server, ANY4);

    assertThat(escaper.escape("The Quick Brown Fox")).isEqualTo("The Quick Brown Fox");
  }

  public void testBuilderInitialStateNoneUnsafe() {
    // No characters are unsafe by default (safeMin == 0, safeMax == 0xFFFF).
    Escaper escaper = Escapers.builder().setUnsafeReplacement("X").build();
    assertThat(escaper.escape("\0\uFFFF")).isEqualTo("\0\uFFFF");
  }

  public void testBuilderRetainsState() {