val response1 = client.newCall(request).execute()
    val in1 = response1.body.source()
    assertThat(in1.readUtf8("I love ".length.toLong())).isEqualTo("I love ")
    in1.skip("puppies but hate ".length.toLong())
    assertThat(in1.readUtf8("spiders".length.toLong())).isEqualTo("spiders")
    assertThat(in1.exhausted()).isTrue()
    in1.close()
    assertThat(cache.writeSuccessCount()).isEqualTo(1)

        rcv_buf = new byte[RCV_BUF_SIZE];
        out = new DatagramPacket( snd_buf, SND_BUF_SIZE, baddr, NAME_SERVICE_UDP_PORT );
        in  = new DatagramPacket( rcv_buf, RCV_BUF_SIZE );

        if( RO == null || RO.length() == 0 ) {

            /* No resolveOrder has been specified, use the
             * default which is LMHOSTS,DNS,WINS,BCAST
             * LMHOSTS,BCAST,DNS if jcifs.smb1.netbios.wins has not
             * been specified.

                BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(dest))) {
            final byte[] buf = new byte[1024];
            int length;
            while (-1 < (length = in.read(buf))) {
                out.write(buf, 0, length);
                out.flush();
            }
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**

      throw new AssertionError(e);
    }
  }

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

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

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

        return 0;
    }


    @Override
    protected int readDataWireFormat ( byte[] buffer, int bufferIndex, int len ) throws SMBProtocolDecodingException {
        if ( len > this.outputBuffer.length ) {
            throw new SMBProtocolDecodingException("Payload exceeds buffer size");
        }
        System.arraycopy(buffer, bufferIndex, this.outputBuffer, 0, len);
        return len;

    }

// FIXME: add support for remote version ID in GCS remote tier and remove this.
// Currently it's a no-op.
func (gcs *warmBackendGCS) Put(ctx context.Context, key string, data io.Reader, length int64) (remoteVersionID, error) {
	return gcs.PutWithMeta(ctx, key, data, length, map[string]string{})
}

func (gcs *warmBackendGCS) Get(ctx context.Context, key string, rv remoteVersionID, opts WarmBackendGetOpts) (r io.ReadCloser, err error) {

                        String[] parts = l.split(splitExpr);
                        if (parts.length < 1) {
                            throw new IllegalArgumentException("Unrecognized entry: " + l);
                        }
                        Artifact s = parseArtifact(parts[0]);
                        Artifact t;
                        if (parts.length > 1) {
                            t = parseArtifact(parts[1]);

  private final String[] decodingInputs = new String[INPUTS_COUNT];

  @BeforeExperiment
  public void setUp() {
    Random rng = new Random();
    for (int i = 0; i < encodingInputs.length; i++) {
      encodingInputs[i] = new byte[n];
      rng.nextBytes(encodingInputs[i]);
      decodingInputs[i] = encoding.encoding.encode(encodingInputs[i]);
    }
  }

  @Benchmark
  public int encode(int reps) {

        int start = bufferIndex;

        if ( this.isExtendedSecurity() ) {
            System.arraycopy(buffer, bufferIndex, this.blob, 0, this.blob.length);
            bufferIndex += this.blob.length;
        }

        this.nativeOs = readString(buffer, bufferIndex);
        bufferIndex += stringWireLength(this.nativeOs, bufferIndex);

  virtual bool HasCustomDeviceInput() const = 0;

  virtual const tensorflow::OpDef* OpDef() const = 0;

  virtual absl::Status InputLength(const char* input_name, int* length) = 0;
  virtual absl::Status OutputLength(const char* output_name, int* length) = 0;

  // Set stack trace to be used for potential async error reporting.
  virtual void SetStackTrace(ManagedStackTrace stack_trace) = 0;