import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

@RunWith(JUnit4.class)
@NullUnmarked
public final class InvalidatableSetTest {
  Set<Integer> wrappedSet;
  Set<Integer> copyOfWrappedSet;
  InvalidatableSet<Integer> setToTest;

  @Before
  public void createSets() {
    wrappedSet = new HashSet<>();
    wrappedSet.add(1);
    wrappedSet.add(2);
    wrappedSet.add(3);

 */

package jcifs.smb1.dcerpc.ndr;

/**
 * NDR representation of a hyper integer (8-byte signed integer).
 */
public class NdrHyper extends NdrObject {

    /**
     * The hyper integer value.
     */
    public long value;

    /**
     * Constructs an NdrHyper with the specified value.
     *
     * @param value the hyper integer value
     */
    public NdrHyper(final long value) {
        this.value = value;

 */

package jcifs.smb1.dcerpc.ndr;

/**
 * NDR representation of a long integer (4-byte signed integer).
 */
public class NdrLong extends NdrObject {

    /**
     * The long integer value.
     */
    public int value;

    /**
     * Constructs an NdrLong with the specified value.
     *
     * @param value the long integer value
     */
    public NdrLong(final int value) {
        this.value = value;

abstract class AbstractAbstractFutureTest extends TestCase {
  @SuppressWarnings("initialization.field.uninitialized")
  private TestedFuture<@Nullable Integer> future;

  @SuppressWarnings("initialization.field.uninitialized")
  private AbstractFuture<@Nullable Integer> delegate;

  abstract AbstractFuture<@Nullable Integer> newDelegate();

  @Override
  protected void setUp() {
    future = TestedFuture.create();
    delegate = newDelegate();
  }

    // need explicit type parameter to avoid javac warning!?
    List<Integer> none = Arrays.<Integer>asList();
    assertThat(Ints.toArray(none)).isEqualTo(EMPTY);

    List<Integer> one = Arrays.asList((int) 1);
    assertThat(Ints.toArray(one)).isEqualTo(ARRAY1);

    int[] array = {(int) 0, (int) 1, (int) 0xdeadbeef};

    List<Integer> three = Arrays.asList((int) 0, (int) 1, (int) 0xdeadbeef);

    @CanIgnoreReturnValue // Sure, why not?
    @Override
    public Integer load(Integer key) {
      countLoad.incrementAndGet();
      return key;
    }

    @J2ktIncompatible
    @GwtIncompatible // reload
    @Override
    public ListenableFuture<Integer> reload(Integer key, Integer oldValue) {
      countReload.incrementAndGet();
      return immediateFuture(oldValue + 1);
    }

     */
    map.put(Integer.class, new Integer(5));
    assertThrows(ClassCastException.class, () -> map.put(Double.class, new Long(42)));
    // Won't compile: map.put(String.class, "x");
  }

  public void testPutAndGetInstance() {
    assertThat(map.putInstance(Integer.class, new Integer(5))).isNull();

    Integer oldValue = map.putInstance(Integer.class, new Integer(7));
    assertEquals(5, (int) oldValue);

@NullUnmarked
public final class SetsFilterNavigableSetTest extends AbstractFilteredNavigableSetTest {
  @Override
  NavigableSet<Integer> createUnfiltered(Iterable<Integer> contents) {
    return Sets.newTreeSet(contents);
  }

  @Override
  NavigableSet<Integer> filter(
      NavigableSet<Integer> elements, Predicate<? super Integer> predicate) {
    return Sets.filter(elements, predicate);
  }

        return this;
    }

    public void setSortOrder_Equal(Integer sortOrder) {
        setSortOrder_Term(sortOrder, null);
    }

    public void setSortOrder_Equal(Integer sortOrder, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setSortOrder_Term(sortOrder, opLambda);
    }

    public void setSortOrder_Term(Integer sortOrder) {
        setSortOrder_Term(sortOrder, null);
    }

    assertFalse(Assignability.of().isAssignable());
    assertTrue(new Assignability<Integer, Integer>() {}.isAssignable());
    assertTrue(new Assignability<Integer, Object>() {}.isAssignable());
    assertFalse(new Assignability<Integer, String>() {}.isAssignable());
    TypeTokenTest.<Number, Integer>assignabilityTestWithTypeVariables();
  }