return new SimpleSession(mavenSession, getRepositorySystem(), repositories);
        }

        @SuppressWarnings("unchecked")
        @Override
        public <T extends Service> T getService(Class<T> clazz) throws NoSuchElementException {
            if (clazz == ArtifactCoordinatesFactory.class) {

    CheckSetUpHashMapGenerator(AtomicBoolean setUpRan) {
      this.setUpRan = setUpRan;
    }

    @Override
    Map<String, String> wrap(HashMap<String, String> map) {
      @SuppressWarnings("unchecked")
      Map<String, String> proxy =
          Reflection.newProxy(Map.class, new CheckSetUpInvocationHandler(map, setUpRan));
      return proxy;
    }
  }

  /**

  private final int[] cellColumnIndices;

  DenseImmutableTable(
      ImmutableList<Cell<R, C, V>> cellList,
      ImmutableSet<R> rowSpace,
      ImmutableSet<C> columnSpace) {
    @SuppressWarnings("unchecked")
    @Nullable V[][] array = (@Nullable V[][]) new Object[rowSpace.size()][columnSpace.size()];
    this.values = array;
    this.rowKeyToIndex = Maps.indexMap(rowSpace);
    this.columnKeyToIndex = Maps.indexMap(columnSpace);

   * the source future indefinitely, so if the source future never completes, the adapter will never
   * complete either.
   *
   * <p>If the delegate future is interrupted or throws an unexpected unchecked exception, the
   * listeners will not be invoked.
   */
  private static final class ListenableFutureAdapter<V extends @Nullable Object>
      extends ForwardingFuture<V> implements ListenableFuture<V> {

                } catch (ModelInterpolationException e) {
                    return e;
                }
            }

            return null;
        }

        @SuppressWarnings({"unchecked", "checkstyle:methodlength"})
        private void traverseObjectWithParents(Class<?> cls, Object target) throws ModelInterpolationException {
            if (cls == null) {
                return;
            }

  public void testSampleCodeFine2() {
    FluentIterable<? extends Number> numbers = getSomeNumbers();

    // Sadly, the following is what users will have to do in some circumstances.

    @SuppressWarnings("unchecked") // safe covariant cast
    Optional<Number> first = (Optional<Number>) numbers.first();
    Number value = first.or(0.5); // fine
  }

  @J2ktIncompatible
  @GwtIncompatible // NullPointerTester

@GwtCompatible
@SuppressWarnings("rawtypes") // https://github.com/google/guava/issues/989
@Immutable(containerOf = "C")
public final class Range<C extends Comparable> implements Predicate<C>, Serializable {
  @SuppressWarnings("unchecked")
  static <C extends Comparable<?>> Ordering<Range<C>> rangeLexOrdering() {
    return (Ordering<Range<C>>) RangeLexOrdering.INSTANCE;
  }

        // Arrange
        byte[] buf;
        if (bufferSupplierOrBytes instanceof byte[]) {
            buf = (byte[]) bufferSupplierOrBytes;
        } else {
            @SuppressWarnings("unchecked")
            java.util.function.Supplier<byte[]> sup = (java.util.function.Supplier<byte[]>) bufferSupplierOrBytes;
            buf = sup.get();
        }

        // Act + Assert

      implements Collection<E> {
    private SynchronizedCollection(Collection<E> delegate, @Nullable Object mutex) {
      super(delegate, mutex);
    }

    @SuppressWarnings("unchecked")
    @Override
    Collection<E> delegate() {
      return (Collection<E>) super.delegate();
    }

    @Override
    public boolean add(E e) {
      synchronized (mutex) {

  public ImmutableMap<K, V> getAllPresent(Iterable<? extends Object> keys) {
    Map<K, V> result = new LinkedHashMap<>();
    for (Object key : keys) {
      if (!result.containsKey(key)) {
        @SuppressWarnings("unchecked")
        K castKey = (K) key;
        V value = getIfPresent(key);
        if (value != null) {
          result.put(castKey, value);
        }
      }
    }
    return ImmutableMap.copyOf(result);
  }