assertTrue(iterator.hasNext());
    assertEquals("a", iterator.next());
    assertThrows(UnsupportedOperationException.class, () -> iterator.remove());
  }

  @SuppressWarnings("DoNotCall")
  public void testAdd() {
    ListIterator<String> iterator = create();

    assertTrue(iterator.hasNext());
    assertEquals("a", iterator.next());
    assertEquals("b", iterator.next());
    assertEquals("b", iterator.previous());

        assertThat(list.getLast(), is("1"));
        list.getLastEntry().remove();
        assertThat(list.size(), is(0));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testAdd() throws Exception {
        list.addLast("1");
        list.addLast("2");
        list.addLast("3");
        list.add(1, "4");
        assertThat(list.get(1), is("4"));
        assertThat(list.get(2), is("2"));

        target.add(4);
        C addThenFilter = filter(createUnfiltered(target), EVEN);

        assertThat(filterThenAdd).containsExactlyElementsIn(addThenFilter);
      }
    }

    public void testAdd() {
      for (List<Integer> contents : SAMPLE_INPUTS) {
        for (int toAdd = 0; toAdd < 10; toAdd++) {
          boolean expectedResult = createUnfiltered(contents).add(toAdd);

      for (RoundingMode mode : ALL_ROUNDING_MODES) {
        assertThrows(ArithmeticException.class, () -> IntMath.divide(p, 0, mode));
      }
    }
  }

  public void testMod() {
    for (int x : ALL_INTEGER_CANDIDATES) {
      for (int m : POSITIVE_INTEGER_CANDIDATES) {
        assertEquals(valueOf(x).mod(valueOf(m)).intValue(), IntMath.mod(x, m));
      }
    }
  }

    // Provide a common OID for tests (Kerberos V5 mechanism OID encoded in DER)
    private static ASN1ObjectIdentifier testOid() {
        return new ASN1ObjectIdentifier("1.2.840.113554.1.2.2");
    }

    private static byte[] oidDer() {
        // Full DER encoding of the OID
        try {
            return testOid().toASN1Primitive().getEncoded();
        } catch (java.io.IOException e) {
            throw new RuntimeException(e);

    assertFalse(invokable.isAnnotationPresent(Tested.class));
  }

  @Retention(RetentionPolicy.RUNTIME)
  @Keep
  private @interface Tested {}

  private abstract static class A {
    @Tested private boolean privateField;
    @Tested int packagePrivateField;
    @Tested protected int protectedField;
    @Tested public String publicField;
    @Tested private static Iterable<String> staticField;

            // Given
            int testMid = 42;

            // When
            Constructor<SmbComNtCancel> constructor = SmbComNtCancel.class.getDeclaredConstructor(Configuration.class, int.class);
            constructor.setAccessible(true);
            SmbComNtCancel cancel = constructor.newInstance(mockConfig, testMid);

            // Then
            assertNotNull(cancel);

import org.jspecify.annotations.Nullable;
import org.junit.Ignore;

/**
 * Testers for {@link SetMultimap#asMap}.
 *
 * @author Louis Wasserman
 * @param <K> The key type of the tested multimap.
 * @param <V> The value type of the tested multimap.
 */
@GwtCompatible
@Ignore("test runners must not instantiate and run this directly, only via suites we build")

        ? Predicates.<T>isNull()
        : new IsEqualToPredicate(target).withNarrowedType();
  }

  /**
   * Returns a predicate that evaluates to {@code true} if the object being tested is an instance of
   * the given class. If the object being tested is {@code null} this predicate evaluates to {@code
   * false}.
   *
   * <p>If you want to filter an {@code Iterable} to narrow its type, consider using {@link

            when(dc.toString()).thenReturn("TESTDC");

            NtlmChallenge nc = new NtlmChallenge(challenge, dc);
            String result = nc.toString();

            // With size = 1 * 2 = 2, Hexdump.toHexString produces "AB"
            assertTrue(result.contains("challenge=0xAB"));
            assertTrue(result.contains("dc=TESTDC"));
        }

        @Test