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)

        // Test text that exceeds maximum length after encoding
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 500; i++) {
            sb.append("0123456789");
        }
        String longText = sb.toString();
        String id = SuggestUtil.createSuggestTextId(longText);
        assertNotNull(id);
        assertEquals(445, id.length()); // Should be truncated to ID_MAX_LENGTH
    }

            final String[] values = entry.getValue();
            if (values == null) {
                // nothing
            } else if (values.length == 1) {
                queryBuf.append(' ').append(key).append(":\"").append(values[0]).append('\"');
            } else if (values.length > 1) {
                boolean first = true;
                queryBuf.append(" (");
                for (final String value : values) {

  }
  TFE_DeleteOp(op);
  return ret;
}

void TFE_OpSetAttrString(TFE_Op* op, const char* attr_name, const void* value,
                         size_t length) {
  auto s = tensorflow::unwrap(op)->SetAttrString(
      attr_name, static_cast<const char*>(value), length);
  if (!s.ok()) {
    LOG(WARNING) << "Unable to set attribute: " << attr_name;
  }
}

                // Attempt to read nativeFileSystem, but don't fail if there are issues
                final int fsLen = this.byteCount - (bufferIndex - start);
                if (fsLen > 0 && fsLen < 256) { // Sanity check on length
                    this.nativeFileSystem = readString(buffer, bufferIndex);
                    bufferIndex += stringWireLength(this.nativeFileSystem, bufferIndex);
                }
            } catch (final Exception e) {

        public long createTime() {
            return 0L;
        }

        @Override
        public long lastModified() {
            return 0L;
        }

        @Override
        public long length() {
            return 0L;
        }

        @Override
        public String toString() {

        .removeHeader("Content-Length")
        .build()
    server.enqueue(responseWithoutBody)
    val call = client.newCall(Request(server.url("/foo")))
    val response = call.execute()

    // Body contains nothing.
    assertThat(response.body.bytes().size).isEqualTo(0)
    assertThat(response.body.contentLength()).isEqualTo(0)

    // Content-Length header doesn't exist in a 204 response.

     */
    public static long sizeOf(final Object obj) {
        if (obj == null) {
            return 0L;
        }
        if (obj instanceof String) {
            return ((String) obj).length() + 56L;
        }
        if (obj instanceof Number) {
            return 24L;
        }
        if (obj instanceof Date) {
            return 32L;
        }
        if (obj instanceof LocalDateTime) {

 * using the latest values obtained from {@link IteratorTester#newTargetIterator()}.
 *
 * <p>The value you pass to the parameter {@code steps} should be greater than the length of your
 * iterator, so that this class can check that your iterator behaves correctly when it is exhausted.
 *
 * <p>For example, to test {@link java.util.Collections#unmodifiableList(java.util.List)

        // Check that the path is written after the referral level
        // The path should be written starting at index 2
        // writeString adds null terminator
        assertTrue(len > 2, "Length should include path");
        String writtenPath = extractStringFromBuffer(buffer, 2, len - 2);
        assertTrue(writtenPath.contains("abc"), "Path should be written to buffer");
    }

    @Test