extends AbstractTableReadTest<C> {

  protected void populate(Table<String, Integer, C> table, @Nullable Object... data) {
    checkArgument(data.length % 3 == 0);
    for (int i = 0; i < data.length; i += 3) {
      table.put(
          (String) data[i], (Integer) data[i + 1], nullableCellValue((Character) data[i + 2]));
    }
  }

  protected boolean supportsRemove() {
    return true;

    @Override
    public List<E> create(Object... elements) {
      return (List<E>) SerializableTester.reserialize(gen.create(elements));
    }

    @Override
    public E[] createArray(int length) {
      return gen.createArray(length);
    }

    @Override
    public Iterable<E> order(List<E> insertionOrder) {
      return gen.order(insertionOrder);
    }
  }

    public static String fromWindowsMapping(final String source) {
        if (isEmpty(source)) {
            return source;
        }
        final char[] array = source.toCharArray();
        for (int i = 0; i < array.length; ++i) {
            array[i] = switch (array[i]) {
            case WAVE_DASH -> FULLWIDTH_TILDE;
            case DOUBLE_VERTICAL_LINE -> PARALLEL_TO;
            case MINUS_SIGN -> FULLWIDTH_HYPHEN_MINUS;

                    final Filter queryFacet = (Filter) aggregation;
                    final String encodedQuery = queryFacet.getName().substring(Constants.FACET_QUERY_PREFIX.length());
                    queryCountMap.put(new String(BaseEncoding.base64().decode(encodedQuery), StandardCharsets.UTF_8),
                            queryFacet.getDocCount());
                }

            });
        }

            return ".*" + Pattern.quote(p.substring(GsaConfigParser.CONTAINS.length())) + ".*";
        }

        if (p.startsWith(GsaConfigParser.REGEXP)) {
            return p.substring(GsaConfigParser.REGEXP.length());
        }

        if (p.startsWith(GsaConfigParser.REGEXP_CASE)) {
            return p.substring(GsaConfigParser.REGEXP_CASE.length());
        }

    byte[] buffer = MANY_VALUES_PAIRED_STATS.toByteArray();
    byte[] tooShortByteArray =
        ByteBuffer.allocate(buffer.length - 1)
            .order(ByteOrder.LITTLE_ENDIAN)
            .put(buffer, 0, buffer.length - 1)
            .array();
    assertThrows(
        IllegalArgumentException.class, () -> PairedStats.fromByteArray(tooShortByteArray));
  }

    byte[] buffer = MANY_VALUES_PAIRED_STATS.toByteArray();
    byte[] tooShortByteArray =
        ByteBuffer.allocate(buffer.length - 1)
            .order(ByteOrder.LITTLE_ENDIAN)
            .put(buffer, 0, buffer.length - 1)
            .array();
    assertThrows(
        IllegalArgumentException.class, () -> PairedStats.fromByteArray(tooShortByteArray));
  }

    assertEquals(SPLIT_LINES, lines);
  }

  public void testCopyTo_appendable() throws IOException {
    StringBuilder builder = new StringBuilder();

    assertEquals(STRING.length(), source.copyTo(builder));
    assertTrue(source.wasStreamOpened() && source.wasStreamClosed());

    assertEquals(STRING, builder.toString());
  }

  public void testCopyTo_charSink() throws IOException {

        String item = list.get(index).trim();
        if (StringUtil.isBlank(item)) {
            return StringUtil.EMPTY;
        }
        if (item.length() > 1 && item.charAt(0) == '"' && item.charAt(item.length() - 1) == '"') {
            item = item.substring(1, item.length() - 1);
        }
        return item;
    }

    protected String[] parsePath(final String path) {
        if (StringUtil.isNotEmpty(path)) {
            final String[] values = path.split("/", 2);
            if (values.length == 2) {
                return values;
            }
            if (values.length == 1 && StringUtil.isNotEmpty(values[0])) {
                return new String[] { values[0], StringUtil.EMPTY };
            }
        }