}

        public MyToken(final String word, final int startOffset, final int endOffset, final int posInc) {
            this(word, startOffset, endOffset, posInc, Integer.MAX_VALUE); // Integer.MAX_VALUE for seq means unused
        }

        public MyToken(final String word, final int startOffset, final int endOffset, final int posInc, final int seq) {
            this.word = word;

        assertEquals("", execJob.lastaEnv);

        // Test with very long timeout
        execJob.timeout(Integer.MAX_VALUE);
        assertEquals(Integer.MAX_VALUE, execJob.timeout);

        // Test with minimum timeout
        execJob.timeout(Integer.MIN_VALUE);
        assertEquals(Integer.MIN_VALUE, execJob.timeout);
    }

    // Test exception handling in execute

    Iterables.addAll(queue, elements);
    return queue;
  }

  // LinkedBlockingDeque

  /**
   * Creates an empty {@code LinkedBlockingDeque} with a capacity of {@link Integer#MAX_VALUE}.
   *
   * @since 12.0
   */
  @J2ktIncompatible
  @GwtIncompatible // LinkedBlockingDeque
  public static <E> LinkedBlockingDeque<E> newLinkedBlockingDeque() {

    return transformValues(new HashMap<String, String>(), Functions.<String>identity());
  }

  @Override
  protected Map<String, String> makePopulatedMap() {
    Map<String, Integer> underlying = new HashMap<>();
    underlying.put("a", 1);
    underlying.put("b", 2);
    underlying.put("c", 3);
    return transformValues(underlying, Functions.toStringFunction());
  }

    return transformValues(Maps.<String, String>newTreeMap(), Functions.<String>identity());
  }

  @Override
  protected SortedMap<String, String> makePopulatedMap() {
    SortedMap<String, Integer> underlying = Maps.newTreeMap();
    underlying.put("a", 1);
    underlying.put("b", 2);
    underlying.put("c", 3);
    return transformValues(underlying, Functions.toStringFunction());
  }

            when(mock.length()).thenReturn(-10L);
            assertEquals(-10L, mock.length());
        }
    }

    @ParameterizedTest(name = "getType returns {0}")
    @ValueSource(ints = { 0, 1, -5, Integer.MAX_VALUE })
    @DisplayName("Parameterized type values")
    void typeParameterized(int type) {
        FileEntry mock = mock(FileEntry.class);
        when(mock.getType()).thenReturn(type);

     */
    protected void setupListCondition(final RoleCB cb, final RolePager rolePager) {
        if (rolePager.id != null) {
            cb.query().docMeta().setId_Equal(rolePager.id);
        }
        // TODO Long, Integer, String supported only.

        // setup condition
        cb.query().addOrderBy_Name_Asc();

        // search

    }

    /**
     * Gets a list of available roles.

    byte[] quad = textToNumericFormatV4(dottedQuad);
    if (quad == null) {
      return null;
    }
    String penultimate = Integer.toHexString(((quad[0] & 0xff) << 8) | (quad[1] & 0xff));
    String ultimate = Integer.toHexString(((quad[2] & 0xff) << 8) | (quad[3] & 0xff));
    return initialPart + penultimate + ":" + ultimate;
  }

        sb.append(":{useTimeZoneHandling=").append(isUseTimeZoneHandling());
        sb.append(", acceptCookieTimeZone=").append(isAcceptCookieTimeZone());
        sb.append("}@").append(Integer.toHexString(hashCode()));
        return sb.toString();
    }

            this.preauthSalt = salt;

            if (config.isEncryptionEnabled()) {
                // Build cipher list based on AES-256 support
                List<Integer> ciphers = new ArrayList<>();

                // Prefer GCM over CCM for better performance
                if (config.isAES256Enabled()) {
                    ciphers.add(EncryptionNegotiateContext.CIPHER_AES256_GCM);