*
     * @param src the source byte array
     * @param si the starting index in the source array
     * @return the decoded long value
     */
    public static long dec_uint64be(final byte[] src, final int si) {
        long l = dec_uint32be(src, si) & 0xFFFFFFFFL;
        l <<= 32L;
        l |= dec_uint32be(src, si + 4) & 0xFFFFFFFFL;
        return l;
    }

    /**

        };
        assertEquals(Long.valueOf(31556926000L), yearEnv.getTimeAdjustTimeMillisAsLong());

        // Test maximum long value
        FessEnv.SimpleImpl maxEnv = new FessEnv.SimpleImpl() {
            protected Properties prepareProperties() {
                Properties props = new Properties();
                props.setProperty(FessEnv.TIME_ADJUST_TIME_MILLIS, String.valueOf(Long.MAX_VALUE));
                return props;

    assertThat(map.getInstance(Integer.class)).isNull();

    map.putInstance(Long.class, null);
    assertTrue(map.containsKey(TypeToken.of(Long.class)));
    assertTrue(map.entrySet().contains(immutableEntry(TypeToken.of(Long.class), null)));
    assertThat(map.get(TypeToken.of(Long.class))).isNull();
    assertThat(map.getInstance(Long.class)).isNull();
  }

  public void testPrimitiveAndWrapper() {

    protected String createdBy;

    /** createdTime */
    protected Long createdTime;

    /** maxSize */
    protected Integer maxSize;

    /** query */
    protected String query;

    /** term */
    protected String term;

    /** updatedBy */
    protected String updatedBy;

    /** updatedTime */
    protected Long updatedTime;

    /** virtualHost */
    protected String virtualHost;

    class SmbFindFileBothDirectoryInfo implements FileEntry {
        int nextEntryOffset;
        int fileIndex;
        long creationTime;
        long lastAccessTime;
        long lastWriteTime;
        long changeTime;
        long endOfFile;
        long allocationSize;
        int extFileAttributes;
        int fileNameLength;
        int eaSize;
        int shortNameLength;
        String shortName;

     * {@inheritDoc}
     *
     * @see jcifs.SmbFileHandle#close(long)
     */
    @Override
    public synchronized void close(final long lastWriteTime) throws CIFSException {
        closeInternal(lastWriteTime, true);
    }

    /**
     * @param lastWriteTime
     * @throws SmbException
     */
    void closeInternal(final long lastWriteTime, final boolean explicit) throws CIFSException {

      tagClass = DerHeader.TAG_CLASS_UNIVERSAL,
      tag = 2L,
      codec =
        object : BasicDerAdapter.Codec<Long> {
          override fun decode(reader: DerReader): Long = reader.readLong()

          override fun encode(
            writer: DerWriter,
            value: Long,
          ) = writer.writeLong(value)
        },
    )

  val INTEGER_AS_BIG_INTEGER =
    BasicDerAdapter(

            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

   */
  public abstract ComparisonChain compare(int left, int right);

  /**
   * Compares two {@code long} values as specified by {@link Long#compare}, <i>if</i> the result of
   * this comparison chain has not already been determined.
   */
  public abstract ComparisonChain compare(long left, long right);

  /**
   * Compares two {@code float} values as specified by {@link Float#compare}, <i>if</i> the result

    /**
     * Maximum number of URLs to access during crawling.
     */
    protected long maxAccessCount = Long.MAX_VALUE;

    /**
     * Interval time in milliseconds between crawling executions.
     */
    protected long crawlingExecutionInterval = Constants.DEFAULT_CRAWLING_EXECUTION_INTERVAL;

    /**
     * Thread priority for index updater operations.
     */