@ValidateTypeFailure
    public Integer crudMode;

    @Required
    @Size(max = 1000)
    public String id;

    @Required
    public String url;

    @Required
    public String threadName;

    public String errorName;

    public String errorLog;

    @Required
    @ValidateTypeFailure
    public String errorCount;

    @Required
    public String lastAccessTime;

        this.lastAccessTime = value;
    }

    public String getThreadName() {
        checkSpecifiedProperty("threadName");
        return convertEmptyToNull(threadName);
    }

    public void setThreadName(String value) {
        registerModifiedProperty("threadName");
        this.threadName = value;
    }

    public String getUrl() {
        checkSpecifiedProperty("url");

    private boolean existNextPage;

    private List<Integer> pageNumberList;

    private int pageSize;

    private int currentPageNumber;

    public String id;

    public String threadName;

    public String errorCount;

    public String lastAccessTime;

    public void clear() {
        allRecordCount = 0;
        allPageCount = 0;
        existPrePage = false;

    }

    public void setThreadName_Equal(String threadName) {
        setThreadName_Term(threadName, null);
    }

    public void setThreadName_Equal(String threadName, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setThreadName_Term(threadName, opLambda);
    }

    public void setThreadName_Term(String threadName) {
        setThreadName_Term(threadName, null);
    }

  private final SynchronousQueue<Response> responseQueue = new SynchronousQueue<>();

  private @Nullable Throwable uncaughtThrowable = null;

  public TestThread(L lockLikeObject, String threadName) {
    super(threadName);
    this.lockLikeObject = checkNotNull(lockLikeObject);
    start();
  }

  // Thread.stop() is okay because all threads started by a test are dying at the end of the test,

  private final SynchronousQueue<Response> responseQueue = new SynchronousQueue<>();

  private @Nullable Throwable uncaughtThrowable = null;

  public TestThread(L lockLikeObject, String threadName) {
    super(threadName);
    this.lockLikeObject = checkNotNull(lockLikeObject);
    start();
  }

  // Thread.stop() is okay because all threads started by a test are dying at the end of the test,

    public void setThreadName_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
        setThreadName_Terms("threadName", opLambda, null);
    }

    public void setThreadName_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsFailureUrlCA> aggsLambda) {
        setThreadName_Terms("threadName", opLambda, aggsLambda);
    }

            null, false, false, false, "Long", 0, 0, null, null, false, null, null, null, null, null, false);
    protected final ColumnInfo _columnThreadName = cci("threadName", "threadName", null, null, String.class, "threadName", null, false,
            false, false, "keyword", 0, 0, null, null, false, null, null, null, null, null, false);

    public String toString() {
        return "FailureUrl [configId=" + configId + ", errorCount=" + errorCount + ", errorLog=" + errorLog + ", errorName=" + errorName
                + ", lastAccessTime=" + lastAccessTime + ", threadName=" + threadName + ", url=" + url + ", docMeta=" + docMeta + "]";
    }

    String threadName = Finalizer.class.getName();
    Thread thread = null;
    if (bigThreadConstructor != null) {
      try {
        boolean inheritThreadLocals = false;
        long defaultStackSize = 0;
        thread =
            bigThreadConstructor.newInstance(
                (ThreadGroup) null, finalizer, threadName, defaultStackSize, inheritThreadLocals);