// Then
            assertEquals(32, bytesConsumed);
            // Note: multiplication may overflow, but that's expected behavior
            long expectedCapacity = Long.MAX_VALUE * (long) Integer.MAX_VALUE * (long) Integer.MAX_VALUE;
            assertEquals(expectedCapacity, fileFsFullSizeInfo.getCapacity());
        }

        @Test

 */
public class CrawlingInfoParam extends BsCrawlingInfoParam {

    private static final long serialVersionUID = 1L;

    private OptionalEntity<CrawlingInfo> crawlingInfo;

    public String getId() {
        return asDocMeta().id();
    }

    public void setId(final String id) {
        asDocMeta().id(id);
    }

    public Long getVersionNo() {
        return asDocMeta().version();
    }

     *
     * @param ts the timestamp value in Windows FILETIME format
     */
    public AvTimestamp(final long ts) {
        this(encode(ts));
    }

    /**
     * @param ts
     * @return
     */
    private static byte[] encode(final long ts) {
        final byte[] data = new byte[8];
        SMBUtil.writeInt8(ts, data, 0);
        return data;
    }

    /**

  }

  public void testAddAndGet() {
    AtomicLongMap<String> map = AtomicLongMap.create();
    String key = "key";
    long addend = random.nextInt(MAX_ADDEND);
    for (int i = 0; i < ITERATIONS; i++) {
      long before = map.get(key);
      long result = map.addAndGet(key, addend);
      long after = map.get(key);
      assertEquals(before + addend, after);
      assertEquals(after, result);
      addend = after;
    }

     */
    public static String getMemoryUsageLog() {
        final Runtime runtime = Runtime.getRuntime();
        final long freeBytes = runtime.freeMemory();
        final long maxBytes = runtime.maxMemory();
        final long totalBytes = runtime.totalMemory();
        final long usedBytes = totalBytes - freeBytes;

            + Long.numberOfLeadingZeros(~a)
            + Long.numberOfLeadingZeros(b)
            + Long.numberOfLeadingZeros(~b);
    if (leadingZeros > Long.SIZE + 1) {
      return a * b;
    }
    // the return value if we will overflow (which we calculate by overflowing a long :) )
    long limit = Long.MAX_VALUE + ((a ^ b) >>> (Long.SIZE - 1));
    if (leadingZeros < Long.SIZE | (a < 0 & b == Long.MIN_VALUE)) {

  private class CountingSource(
    source: Source,
  ) : ForwardingSource(source) {
    var bytesRead = 0L

    override fun read(
      sink: Buffer,
      byteCount: Long,
    ): Long {
      val result = delegate.read(sink, byteCount)
      if (result == -1L) return -1L
      bytesRead += result
      return result
    }
  }

    }
  }
  return result
}

internal const val USER_AGENT: String = "okhttp/${CONST_VERSION}"

internal fun checkOffsetAndCount(
  arrayLength: Long,
  offset: Long,
  count: Long,
) {
  if (offset or count < 0L || offset > arrayLength || arrayLength - offset < count) {
    throw ArrayIndexOutOfBoundsException("length=$arrayLength, offset=$offset, count=$offset")
  }
}

        "type": "keyword"
      },
      "createdBy": {
        "type": "keyword"
      },
      "createdTime": {
        "type": "long"
      },
      "updatedBy": {
        "type": "keyword"
      },
      "updatedTime": {
        "type": "long"
      }
    }

      "sortOrder": {
        "type": "integer"
      },
      "createdBy": {
        "type": "keyword"
      },
      "createdTime": {
        "type": "long"
      },
      "updatedBy": {
        "type": "keyword"
      },
      "updatedTime": {
        "type": "long"
      }
    }