object : Callback {
            override fun onRedirectReceived(
              request: UrlRequest,
              info: UrlResponseInfo,
              newLocationUrl: String,
            ) {
              println("request " + info.httpStatusCode + " " + newLocationUrl)
              request.followRedirect()
            }

            override fun onResponseStarted(
              request: UrlRequest,

            }
        } else {
            openFunction = OPEN_FN_OPEN;
        }
    }

    @Override
    int getBatchLimit(final byte command) {
        return command == SMB_COM_READ_ANDX ? BATCH_LIMIT : 0;
    }

    @Override
    int writeParameterWordsWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

        writeInt2(flags, dst, dstIndex);

            new LineProcessor<List<String>>() {
              final List<String> list = new ArrayList<>();

              @Override
              public boolean processLine(String line) throws IOException {
                list.add(line);
                return true;
              }

              @Override
              public List<String> getResult() {
                return list;
              }
            });

        }

        // Stub implementations of the abstract methods
        @Override
        int writeSetupWireFormat(byte[] dst, int dstIndex) {
            return 0;
        }

        @Override
        int writeParametersWireFormat(byte[] dst, int dstIndex) {
            return 0;
        }

        @Override
        int writeDataWireFormat(byte[] dst, int dstIndex) {
            return 0;
        }

     */

    @Override
    public int read(final byte[] b) throws IOException {
        return read(b, 0, b.length);
    }

    /**
     * Reads up to len bytes of data from this input stream into an array of bytes.
     *
     * @throws IOException if a network error occurs
     */

    @Override

      this.gen = gen;
    }

    @Override
    public SampleElements<E> samples() {
      return gen.samples();
    }

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

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

    @Override

        return dstIndex - start;
    }

    @Override
    protected int readParameterWordsWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override
    protected int readBytesWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override
    public String toString() {

     */
    public String getContent() {
        return content;
    }

    @Override
    public String toString() {
        return getLocation();
    }

    @Override
    public int hashCode() {
        return hashCode;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

@GwtCompatible
public interface SortedMapDifference<K extends @Nullable Object, V extends @Nullable Object>
    extends MapDifference<K, V> {

  @Override
  SortedMap<K, V> entriesOnlyOnLeft();

  @Override
  SortedMap<K, V> entriesOnlyOnRight();

  @Override
  SortedMap<K, V> entriesInCommon();

  @Override
  SortedMap<K, ValueDifference<V>> entriesDiffering();

  Murmur3_128HashFunction(int seed) {
    this.seed = seed;
  }

  @Override
  public int bits() {
    return 128;
  }

  @Override
  public Hasher newHasher() {
    return new Murmur3_128Hasher(seed);
  }

  @Override
  public String toString() {
    return "Hashing.murmur3_128(" + seed + ")";
  }

  @Override
  public boolean equals(@Nullable Object object) {