SortedMap<Integer, Character> row = sortedTable.row("c");
    assertEquals(2, row.size());
    assertEquals(1, row.tailMap(15).size());
  }

  public void testSubRowClearAndPut() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    SortedMap<Integer, Character> row = (SortedMap<Integer, Character>) table.row("foo");
    SortedMap<Integer, Character> subRow = row.tailMap(2);

     */
    int getColumnNumber();

    /**
     * Return the byte or character offset into the input source this location
     * is pointing to. If the input source is a file or a byte stream then
     * this is the byte offset into that stream, but if the input source is
     * a character media then the offset is the character offset.
     * Returns -1 if there is no offset available.
     * @return the current offset
     */

  abstract Iterable<ImmutableTable<Character, Integer, String>> getTestInstances();

  public final void testClear() {
    for (Table<Character, Integer, String> testInstance : getTestInstances()) {
      assertThrows(UnsupportedOperationException.class, () -> testInstance.clear());
    }
  }

  public final void testPut() {
    for (Table<Character, Integer, String> testInstance : getTestInstances()) {

        String msg = "\u00A1\u00A2"; // two Unicode characters
        byte[] encoded = encodeUnicode(msg);
        assertEquals(4, encoded.length, "Encoded Unicode string should be 4 bytes");

        // Verify little-endian encoding
        assertEquals((byte) 0xA1, encoded[0], "First byte of first character");
        assertEquals((byte) 0x00, encoded[1], "Second byte of first character");

  }

  @Override
  TreeBasedTable<String, Integer, Character> makeTable() {
    TreeBasedTable<String, Integer, Character> table = TreeBasedTable.create();
    table.put("a", 1, 'a');
    table.put("z", 1, 'a');
    return table;
  }

  @Override
  protected Map<String, Map<Integer, Character>> makePopulatedMap() {
    TreeBasedTable<String, Integer, Character> table = makeTable();
    populateTable(table);

    Cell<String, Integer, Character> entry = immutableCell("foo", 1, 'a');
    SerializableTester.reserializeAndAssert(entry);
  }

  public void testImmutableEntryToString() {
    Cell<String, Integer, Character> entry = immutableCell("foo", 1, 'a');
    assertThat(entry.toString()).isEqualTo("(foo,1)=a");

    Cell<@Nullable String, @Nullable Integer, @Nullable Character> nullEntry =
        immutableCell(null, null, null);

    // which means they are treated as pairs of safe characters).
    builder.setSafeRange(Character.MIN_VALUE, '\uFFFD');
    // Unsafe characters are replaced with the Unicode replacement character.
    builder.setUnsafeReplacement("\uFFFD");

    /*
     * Except for \n, \t, and \r, all ASCII control characters are replaced with the Unicode
     * replacement character.
     *

   * modification operations, but reflects any changes to the underlying character sequence.
   *
   * @param sequence the character sequence to view as a {@code List} of characters
   * @return an {@code List<Character>} view of the character sequence
   * @since 7.0
   */
  public static List<Character> charactersOf(CharSequence sequence) {
    return new CharSequenceAsList(checkNotNull(sequence));
  }

   *
   * <ul>
   *   <li>The alphanumeric characters "a" through "z", "A" through "Z" and "0" through "9" remain
   *       the same.
   *   <li>The special characters ".", "-", "*", and "_" remain the same.
   *   <li>The space character " " is converted into a plus sign "+".
   *   <li>All other characters are converted into one or more bytes using UTF-8 encoding and each

package jstream

import (
	"fmt"
	"strconv"
)

// Predefined errors
var (
	ErrSyntax        = DecoderError{msg: "invalid character"}
	ErrUnexpectedEOF = DecoderError{msg: "unexpected end of JSON input"}
	ErrMaxDepth      = DecoderError{msg: "maximum recursion depth exceeded"}
)

type errPos [2]int // line number, byte offset where error occurred

// DecoderError contains a detailed decoding error.
type DecoderError struct {