new Strategy() {
          @Override
          public SplittingIterator iterator(Splitter splitter, final CharSequence toSplit) {
            return new SplittingIterator(splitter, toSplit) {
              @Override
              int separatorStart(int start) {
                return separatorMatcher.indexIn(toSplit, start);
              }

              @Override

        new ByteProcessor<byte[]>() {
          int pos;

          @Override
          public boolean processBytes(byte[] buf, int off, int len) throws IOException {
            System.arraycopy(buf, off, processedBytes, pos, len);
            pos += len;
            return true;
          }

          @Override
          public byte[] getResult() {
            return processedBytes;
          }

    tag: Long,
    forceConstructed: Boolean? = null,
  ): BasicDerAdapter<T> {
    val codec =
      object : BasicDerAdapter.Codec<T> {
        override fun decode(reader: DerReader): T = fromDer(reader)

        override fun encode(
          writer: DerWriter,
          value: T,
        ) {
          toDer(writer, value)
          if (forceConstructed != null) {

      this.master = master;
    }

    @Override
    protected Iterator<T> newTargetIterator() {
      // make copy from master to verify later
      targetList = Lists.newArrayList(master);
      Iterator<T> iterator = targetList.iterator();
      return Iterators.peekingIterator(iterator);
    }

    @Override
    protected void verify(List<T> elements) {

    //                                                                             =======
    @Override
    public DataConfigDbm asDBMeta() {
        return DataConfigDbm.getInstance();
    }

    @Override
    public String asTableDbName() {
        return "data_config";
    }

    // ===================================================================================

public abstract class TestCollidingSetGenerator implements TestSetGenerator<Object> {
  @Override
  public SampleElements<Object> samples() {
    return new Colliders();
  }

  @Override
  public Object[] createArray(int length) {
    return new Object[length];
  }

  /** Returns the original element list, unchanged. */
  @Override
  public List<Object> order(List<Object> insertionOrder) {
    return insertionOrder;
  }

              },
              {
                "color": "red",
                "value": 80
              }
            ]
          },
          "unit": "ops"
        },
        "overrides": []
      },
      "gridPos": {
        "h": 4,
        "w": 6,
        "x": 0,
        "y": 4
      },
      "id": 12,
      "links": [],
      "maxDataPoints": 100,
      "options": {

    @Override
    public int length() {
      return 3;
    }

    @Override
    public char charAt(int index) {
      return "foo".charAt(index);
    }

    @Override
    public CharSequence subSequence(int start, int end) {
      return "foo".subSequence(start, end);
    }

    @Override
    public String toString() {

            @Override
            public int getPathConsumed () {
                return 2 + hostname.length() + root.length() + path.length();
            }


            @Override
            public String getServer () {
                return getTestServer();
            }


            @Override
            public void stripPathConsumed ( int i ) {}
        };

    }
  }
}

object LoggingCallback : FutureCallback<SimpleHttpResponse> {
  override fun completed(response: SimpleHttpResponse) {
  }

  override fun failed(ex: Exception) {
    println("Failed: $ex")
  }

  override fun cancelled() {
    println("Cancelled")
  }