/** Timeout for PDF extraction in milliseconds (default: 30 seconds). */
    protected long timeout = 30000; // 30sec

    /** Whether the extraction thread should be a daemon thread. */
    protected boolean isDaemonThread = false;

    /**
     * Creates a new PdfExtractor instance.
     */
    public PdfExtractor() {
        super();
    }

    /*
     * (non-Javadoc)
     *

  }

  final boolean supportsFastOffset;

  /** Constructor for use by subclasses. */
  protected DiscreteDomain() {
    this(false);
  }

  /** Private constructor for built-in DiscreteDomains supporting fast offset. */
  private DiscreteDomain(boolean supportsFastOffset) {
    this.supportsFastOffset = supportsFastOffset;
  }

  /**

  private transient int lastEntry;

  private final boolean accessOrder;

  CompactLinkedHashMap() {
    this(CompactHashing.DEFAULT_SIZE);
  }

  CompactLinkedHashMap(int expectedSize) {
    this(expectedSize, false);
  }

  CompactLinkedHashMap(int expectedSize, boolean accessOrder) {
    super(expectedSize);
    this.accessOrder = accessOrder;
  }

            assertTrue(mockReferralData.isResolveHashes());
            verify(mockReferralData, times(1)).isResolveHashes();

            // Test with concrete implementation
            boolean result = concreteImplementation.isResolveHashes();
            assertNotNull(result);
        }

        @Test
        @DisplayName("Should check if intermediate")
        void testIsIntermediate() {

        return ElevateWordToLabelDbm.getInstance();
    }

    @Override
    public String asTableDbName() {
        return "elevate_word_to_label";
    }

    @Override
    public boolean hasSpecifiedColumn() {
        return _specification != null;
    }

    @Override
    public ConditionQuery localCQ() {
        return doGetConditionQuery();
    }

     */
    void setUid(int uid);

    /**
     * Sets whether extended security is enabled.
     *
     * @param extendedSecurity true to enable extended security
     */
    void setExtendedSecurity(boolean extendedSecurity);

    /**
     * Sets the session ID.
     *
     * @param sessionId the session ID to set
     */
    void setSessionId(long sessionId);

    /**

        setCount(element, count));
  }

  @Override
  void setCountNoCheckReturnValue(E element, int count) {
    setCount(element, count);
  }

  @CanIgnoreReturnValue
  private boolean setCount(E element, int count) {
    return getMultiset().setCount(element, getMultiset().count(element), count);
  }

  private void assertSetCountNegativeOldCount() {
    try {
      getMultiset().setCount(e3(), -1, 1);

    return suite;
  }

  public void testIteratesOnce() {
    Map<AnEnum, AnEnum> map =
        Maps.asMap(
            ImmutableSet.of(AnEnum.A),
            new Function<AnEnum, AnEnum>() {
              boolean used = false;

              @Override
              public AnEnum apply(AnEnum ae) {
                checkState(!used, "should not be applied more than once");
                used = true;
                return ae;

 *
 * @author Dimitris Andreou
 */
abstract class AbstractHasher implements Hasher {
  @Override
  @CanIgnoreReturnValue
  public final Hasher putBoolean(boolean b) {
    return putByte(b ? (byte) 1 : (byte) 0);
  }

  @Override
  @CanIgnoreReturnValue
  public final Hasher putDouble(double d) {
    return putLong(Double.doubleToRawLongBits(d));
  }

  @Override

    void testConcurrentAccess() throws InterruptedException {
        // Given
        final int threadCount = 10;
        final Thread[] threads = new Thread[threadCount];
        final boolean[] results = new boolean[threadCount];

        // When
        for (int i = 0; i < threadCount; i++) {
            final int index = i;
            threads[i] = new Thread(() -> {
                try {