if (format.contains("epoch_millis")) {
            return Long.toString(date.getTime());
        } else if (format.contains("date_optional_time")) {
            final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
            sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
            return sdf.format(date);
        } else {
            return Long.toString(date.getTime());
        }
    }

     * @return The total number of words.
     */
    public long getAllWordsNum() {
        return getNum(QueryBuilders.matchAllQuery());
    }

    /**
     * Returns the number of document words in the suggestion index.
     * @return The number of document words.
     */
    public long getDocumentWordsNum() {
        return getNum(QueryBuilders.rangeQuery(FieldNames.DOC_FREQ).gte(1));

/**
 * Exception that wraps {@link InstantiationException}.
 *
 * @author higa
 */
public class InstantiationRuntimeException extends ClRuntimeException {

    private static final long serialVersionUID = 5220902071756706607L;

    /**
     * The target class.
     */
    private final Class<?> targetClass;

    /**
     * Creates a {@link InstantiationRuntimeException}.
     *

import org.dbflute.utflute.core.PlainTestCase;

/**
 * @author shinsuke
 *
 */
public class ContentLengthHelperTest extends PlainTestCase {
    private static long DEFAULT_MAX_LENGTH = 10L * 1024L * 1024L;

    public ContentLengthHelper contentLengthHelper;

    @Override
    protected void setUp() throws Exception {
        super.setUp();

 * It can be used to wrap underlying storage exceptions, providing a
 * consistent error handling mechanism for storage operations.
 */
public class StorageException extends FessSystemException {
    private static final long serialVersionUID = 1L;

    /**
     * Constructs a new storage exception with the specified detail message and cause.
     *
     * @param message The detail message.
     * @param cause   The cause of the exception.

 * reading, writing, parsing, or other dictionary-related operations.
 */
public class DictionaryException extends FessSystemException {

    /** Serial version UID for serialization. */
    private static final long serialVersionUID = 1L;

    /**
     * Creates a new DictionaryException with the specified message and cause.
     *
     * @param message the detail message
     * @param cause the underlying cause of the exception

    return source;
  }

  @Override
  public String getMessage() {
    return super.getMessage() + " (source: " + source + ")";
  }

  @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;

    var flags: Int = 0
    var streamId: Int = 0

    var left: Int = 0
    var padding: Int = 0

    @Throws(IOException::class)
    override fun read(
      sink: Buffer,
      byteCount: Long,
    ): Long {
      while (left == 0) {
        source.skip(padding.toLong())
        padding = 0
        if (flags and FLAG_END_HEADERS != 0) return -1L
        readContinuationHeader()

   * @param values a series of values, which will be converted to {@code double} values (this may
   *     cause loss of precision for longs of magnitude over 2^53 (slightly over 9e15))
   */
  public void addAll(long... values) {
    for (long value : values) {
      add(value);
    }
  }

  /**
   * Adds the given values to the dataset. The stream will be completely consumed by this method.
   *

  private static final BigDecimal MIN_INT_AS_BIG_DECIMAL = BigDecimal.valueOf(Integer.MIN_VALUE);

  private static final BigDecimal MAX_LONG_AS_BIG_DECIMAL = BigDecimal.valueOf(Long.MAX_VALUE);
  private static final BigDecimal MIN_LONG_AS_BIG_DECIMAL = BigDecimal.valueOf(Long.MIN_VALUE);

  public void testConstantsMaxFactorial() {
    BigInteger maxDoubleValue = BigDecimal.valueOf(Double.MAX_VALUE).toBigInteger();