public class UnmodifiableCollectionTests {

  public static void assertMapEntryIsUnmodifiable(Entry<?, ?> entry) {
    try {
      // fine because the call is going to fail without modifying the entry
      @SuppressWarnings("unchecked")
      Entry<?, @Nullable Object> nullableValueEntry = (Entry<?, @Nullable Object>) entry;
      nullableValueEntry.setValue(null);
      fail("setValue on unmodifiable Map.Entry succeeded");

    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 =

   * This does perform a little more work than necessary, so another option is to insert an
   * unchecked cast at some later point:
   *
   * {@snippet :
   * @SuppressWarnings("unchecked") // safe because of ::isInstance check
   * ImmutableList<NewType> result =
   *     (ImmutableList) stream.filter(NewType.class::isInstance).collect(toImmutableList());
   * }

        if (!context.getConfig().isUseMultiChannel()) {
            return false;
        }

        // MS-SMB2: Check if server advertised SMB2_GLOBAL_CAP_MULTI_CHANNEL (0x00000008)
        // This capability should be checked from the negotiate response
        // The server capabilities are typically stored in the session or transport

        // TODO: Integration point - check server capabilities

            final Map<String, Object> defaultSettings = defaultSettings();
            initialSettings.forEach((key, value) -> {
                if (value instanceof Collection) {
                    @SuppressWarnings("unchecked")
                    final Collection<Object> collection = (Collection<Object>) value;
                    collection.forEach(element -> arraySettings.add(new Tuple<>(key, element)));

    assertThrows(UncheckedExecutionException.class, () -> cache.getUnchecked("bar"));
    assertThat(callCount.get()).isEqualTo(2);
  }

  /**
   * On a concurrent computation that throws a checked exception, all threads should get the
   * (wrapped) exception, with the loader called only once. The result should not be cached (a later
   * request should call the loader again).
   */

   * 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;

public class UnmodifiableCollectionTests {

  public static void assertMapEntryIsUnmodifiable(Entry<?, ?> entry) {
    try {
      // fine because the call is going to fail without modifying the entry
      @SuppressWarnings("unchecked")
      Entry<?, @Nullable Object> nullableValueEntry = (Entry<?, @Nullable Object>) entry;
      nullableValueEntry.setValue(null);
      fail("setValue on unmodifiable Map.Entry succeeded");

        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() {

        }
        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;
        }