}
        return getNegotiateResponse().isSigningRequired();
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbTransport#unwrap(java.lang.Class)
     */
    @SuppressWarnings("unchecked")
    @Override
    public <T extends SmbTransport> T unwrap(final Class<T> type) {
        if (type.isAssignableFrom(this.getClass())) {
            return (T) this;
        }

   * bufferSize ≥ k, then we can ignore any elements greater than this value.
   */
  private @Nullable T threshold;

  @SuppressWarnings("unchecked") // TODO(cpovirk): Consider storing Object[] instead of T[].
  private TopKSelector(Comparator<? super T> comparator, int k) {
    this.comparator = checkNotNull(comparator, "comparator");
    this.k = k;

                option.converter(new EsTimestampConverter(), timestampFields).excludeWhitespace();
                option.exclude(OpenSearchAccessResult.ACCESS_RESULT_DATA);
            });
            @SuppressWarnings("unchecked")
            final Map<String, Object> data = (Map<String, Object>) source.get(OpenSearchAccessResult.ACCESS_RESULT_DATA);
            if (data != null) {

        typeVariables = getTypeVariableMap(beanClass);
        setupConstructorDescs();
        setupPropertyDescs();
        setupMethodDescs();
        setupFieldDescs();
    }

    @SuppressWarnings("unchecked")
    @Override
    public <T> Class<T> getBeanClass() {
        return (Class<T>) beanClass;
    }

    @Override
    public Map<TypeVariable<?>, Type> getTypeVariables() {
        return typeVariables;

    }

    /**
     * Converts a string to a {@link Date}.
     *
     * @param str the string
     * @param locale the locale
     * @return the converted {@link Date}
     */
    @SuppressWarnings("unchecked")
    protected static Date toDate(final String str, final Locale locale) {
        for (final DateFormat format : iterable(new DateFormatIterator(locale), new PlainDateFormatIterator(str, locale))) {

     *
     * @param session the HTTP session
     * @return the result document IDs cache map
     */
    private Map<String, String[]> getResultDocIdsCache(final HttpSession session) {
        @SuppressWarnings("unchecked")
        Map<String, String[]> resultDocIdsCache = (Map<String, String[]>) session.getAttribute(Constants.RESULT_DOC_ID_CACHE);
        if (resultDocIdsCache == null) {

                        logger.warn("No transformer: {}", accessResultData.getTransformerName());
                        continue;
                    }
                    @SuppressWarnings("unchecked")
                    final Map<String, Object> map = (Map<String, Object>) transformer.getData(accessResultData);
                    if (map.isEmpty()) {
                        // no transformer

    sampleData = sampleDataList.toArray(new String[sampleDataList.size()]);
  }

  // Since we can't pass a concrete SomeEnum.class directly, we need to use a raw type.
  @SuppressWarnings("unchecked")
  @Benchmark
  boolean getIfPresent(int repetitions) {
    boolean retVal = false;
    for (int i = 0; i < repetitions; ++i) {
      retVal &= Enums.getIfPresent(enumType, sampleData[i & 255]).isPresent();
    }

    assertThat(set0).isEmpty();

    @SuppressWarnings("unchecked") // using a legacy comparable
    ImmutableSortedSet<LegacyComparable> set1 = ImmutableSortedSet.of(LegacyComparable.Z);
    assertThat(set1).containsExactly(LegacyComparable.Z);

    @SuppressWarnings("unchecked") // using a legacy comparable
    ImmutableSortedSet<LegacyComparable> set2 =

        assertEquals(25L, updated.get(FieldNames.QUERY_FREQ)); // 20 + 5
        assertEquals(20L, updated.get(FieldNames.DOC_FREQ)); // 10 + 10

        @SuppressWarnings("unchecked")
        List<String> tags = (List<String>) updated.get(FieldNames.TAGS);
        assertTrue(tags.contains("existing"));
    }

    @Test
    public void testConcatValues() {