@SuppressWarnings("deprecation")
        final String encrypted1 = cipher.encryptText(original);
        @SuppressWarnings("deprecation")
        final String decrypted1 = cipher.decryptoText(encrypted1);
        assertThat(decrypted1, is(original));

        // Encrypt with old method, decrypt with new method
        @SuppressWarnings("deprecation")

    public Set<Object> create(Object... elements) {
      return ImmutableSet.copyOf(elements);
    }
  }

  public static class DegeneratedImmutableSetGenerator extends TestStringSetGenerator {
    @SuppressWarnings("DistinctVarargsChecker") // deliberately testing deduplication
    @Override
    protected Set<String> create(String[] elements) {
      return ImmutableSet.of(elements[0], elements[0]);
    }
  }

/**
 * Tests for {@link Multimap#putAll(Object, Iterable)}.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@Ignore("test runners must not instantiate and run this directly, only via suites we build")
@SuppressWarnings({
  // @Ignore affects the Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
  "JUnit4ClassUsedInJUnit3",
  // We use ::iterator so that we test passing a plain Iterable, not a Collection.

@SuppressWarnings("module")
module okhttp3.dnsoverhttps {
  requires okhttp3;
  exports okhttp3.dnsoverhttps;

            final ResourceNameFilter filter, final int searchAttributes) throws CIFSException {
        super(th, parent, wildcard, filter, searchAttributes);
    }

    @SuppressWarnings("resource")
    @Override
    protected final FileEntry open() throws CIFSException {
        final SmbResourceLocator loc = this.getParent().getLocator();
        final String unc = loc.getUNCPath();

 */
@GwtCompatible
@Ignore("test runners must not instantiate and run this directly, only via suites we build")
// @Ignore affects the Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class MultimapReplaceValuesTester<K, V>
    extends AbstractMultimapTester<K, V, Multimap<K, V>> {

  @MapFeature.Require({SUPPORTS_PUT, SUPPORTS_REMOVE, ALLOWS_NULL_VALUES})

  private final ImmutableMap<C, ImmutableMap<R, V>> columnMap;

  @SuppressWarnings("Immutable") // We don't modify this after construction.
  private final int[] rowCounts;

  @SuppressWarnings("Immutable") // We don't modify this after construction.
  private final int[] columnCounts;

  @SuppressWarnings("Immutable") // We don't modify this after construction.
  private final @Nullable V[][] values;

  }

  @SuppressWarnings("unused") // for NullPointerTester
  private static class SubclassOverridesTheWrongMethod extends BaseClassThatFailsToThrow {
    @Keep
    public void oneArg(@Nullable CharSequence s) {}
  }

  public void testSubclassOverridesTheWrongMethod() {
    shouldFail(new SubclassOverridesTheWrongMethod());
  }

  @SuppressWarnings("unused") // for NullPointerTester

                    return singletonMap(entry.getKey(), entry.getValue());
                default:
                    return new MapN<>(map);
            }
        }
    }

    @SuppressWarnings("unchecked")
    static <K, V> Map<K, V> emptyMap() {
        return (Map<K, V>) EMPTY_MAP;
    }

    static <K, V> Map<K, V> singletonMap(K key, V value) {
        return new Map1<>(key, value);
    }

  }

  @SuppressWarnings("OptionalOfRedundantMethod") // Unit tests for Optional
  public void testOr_t_present() {
    assertEquals("a", Optional.of("a").or("default"));
  }

  public void testOr_t_absent() {
    assertEquals("default", Optional.absent().or("default"));
  }

  @SuppressWarnings("OptionalOfRedundantMethod") // Unit tests for Optional