}

    public void setLastAccessTime_Equal(Long lastAccessTime) {
        setLastAccessTime_Term(lastAccessTime, null);
    }

    public void setLastAccessTime_Equal(Long lastAccessTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setLastAccessTime_Term(lastAccessTime, opLambda);
    }

    public void setLastAccessTime_Term(Long lastAccessTime) {

      Runnable command, long initialDelay, long period, TimeUnit unit) {
    return delegate.scheduleAtFixedRate(wrapTask(command), initialDelay, period, unit);
  }

  @Override
  public final ScheduledFuture<?> scheduleWithFixedDelay(
      Runnable command, long initialDelay, long delay, TimeUnit unit) {
    return delegate.scheduleWithFixedDelay(wrapTask(command), initialDelay, delay, unit);
  }

            getExpiredTimeMethod.setAccessible(true);

            long result1 = (Long) getExpiredTimeMethod.invoke(crawlingInfoHelper, 1);
            long result7 = (Long) getExpiredTimeMethod.invoke(crawlingInfoHelper, 7);
            long result0 = (Long) getExpiredTimeMethod.invoke(crawlingInfoHelper, 0);

            // Verify that results are reasonable relative to each other

        return this;
    }

    public void setCreatedTime_Equal(Long createdTime) {
        setCreatedTime_Term(createdTime, null);
    }

    public void setCreatedTime_Equal(Long createdTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setCreatedTime_Term(createdTime, opLambda);
    }

    public void setCreatedTime_Term(Long createdTime) {
        setCreatedTime_Term(createdTime, null);
    }

      },
      "sessionId": {
        "type": "keyword"
      },
      "url": {
        "type": "keyword"
      },
      "executionTime": {
        "type": "long"
      },
      "createTime": {
        "type": "long"
      },
      "accessResultData": {
        "properties": {
          "transformerName": {
            "type": "keyword"
          },
          "encoding": {

        // Arrange: Build sequence with invalid version and otherwise valid tags
        ASN1EncodableVector v = new ASN1EncodableVector();
        v.add(new DERTaggedObject(true, 0, new ASN1Integer(badPvno))); // wrong pvno
        v.add(new DERTaggedObject(true, 1, new ASN1Integer(Integer.parseInt(KerberosConstants.KERBEROS_AP_REQ))));
        v.add(new DERTaggedObject(true, 2, new DERBitString(new byte[] { 0x00 })));

        public final State state;
        public final long totalCalls;
        public final long totalSuccesses;
        public final long totalFailures;
        public final long rejectedCalls;
        public final int consecutiveFailures;
        public final double successRate;

        public Statistics(String name, State state, long totalCalls, long totalSuccesses, long totalFailures, long rejectedCalls,

   */
  var constructed: Boolean,
  /** Length of the message in bytes, or -1L if its length is unknown at the time of encoding. */
  var length: Long,
) {
  val isEndOfData: Boolean
    get() = tagClass == TAG_CLASS_UNIVERSAL && tag == TAG_END_OF_CONTENTS

  // Avoid Long.hashCode(long) which isn't available on Android 5.
  override fun hashCode(): Int {
    var result = 0
    result = 31 * result + tagClass

    //                                                                            ========
    public Long getGidNumber() {
        checkSpecifiedProperty("gidNumber");
        return gidNumber;
    }

    public void setGidNumber(Long value) {
        registerModifiedProperty("gidNumber");
        this.gidNumber = value;
    }

    public String getName() {

) {
  /** The total number of bytes consumed. */
  var total: Long = 0L
    private set

  /** The total number of bytes acknowledged by outgoing `WINDOW_UPDATE` frames. */
  var acknowledged: Long = 0L
    private set

  val unacknowledged: Long
    @Synchronized get() = total - acknowledged

  @Synchronized
  fun update(
    total: Long = 0,
    acknowledged: Long = 0,
  ) {
    check(total >= 0)