assertThrows(
        ConcurrentModificationException.class,
        () -> {
          Iterator<V> iterator = getMap().values().iterator();
          put(e3());
          iterator.next();
        });
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  public void testPut_unsupportedNotPresent() {
    assertThrows(UnsupportedOperationException.class, () -> put(e3()));

            byte[] buf = new byte[] { 1, 2, 3 };
            assertThrows(CIFSException.class, () -> ctx.initSecContext(buf, -1, 1));
            assertThrows(CIFSException.class, () -> ctx.initSecContext(buf, 0, -1));
            assertThrows(CIFSException.class, () -> ctx.initSecContext(buf, 3, 1));
            assertThrows(CIFSException.class, () -> ctx.initSecContext(buf, 2, 2));
        }

        @Test

    ImmutableSortedMultiset.Builder<String> builder = ImmutableSortedMultiset.naturalOrder();
    assertThrows(NullPointerException.class, () -> builder.add((String) null));
  }

  public void testBuilderAddAllHandlesNullsCorrectly() {
    {
      ImmutableSortedMultiset.Builder<String> builder = ImmutableSortedMultiset.naturalOrder();
      assertThrows(NullPointerException.class, () -> builder.addAll((Collection<String>) null));
    }

    assertSize(3);
    assertThrows(NullPointerException.class, () -> table.put(null, 2, cellValue('d')));
    assertThrows(NullPointerException.class, () -> table.put("cat", null, cellValue('d')));
    if (supportsNullValues()) {
      assertThat(table.put("cat", 2, null)).isNull();
      assertTrue(table.contains("cat", 2));
    } else {
      assertThrows(NullPointerException.class, () -> table.put("cat", 2, null));

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.escape;

import static com.google.common.escape.ReflectionFreeAssertThrows.assertThrows;
import static com.google.common.truth.Truth.assertThat;

import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.ImmutableMap;
import com.google.common.escape.testing.EscaperAsserts;

      assertThrows(NullPointerException.class, () -> builder.add((String) null));
    }

    {
      ImmutableSet.Builder<String> builder = this.<String>builder();
      assertThrows(NullPointerException.class, () -> builder.add((String[]) null));
    }

    {
      ImmutableSet.Builder<String> builder = this.<String>builder();

    Entry<K, V>[] entries = getEntriesMultipleNullKeys();
    assertThrows(IllegalArgumentException.class, () -> resetMap(entries));
  }

  @MapFeature.Require(REJECTS_DUPLICATES_AT_CREATION)
  @CollectionSize.Require(absent = {ZERO, ONE})
  public void testCreateWithDuplicates_nonNullDuplicatesRejected() {
    Entry<K, V>[] entries = getEntriesMultipleNonNullKeys();
    assertThrows(IllegalArgumentException.class, () -> resetMap(entries));
  }

        assertThrows(
                IllegalArgumentException.class,
                () -> rtInfo.isMavenVersion("[3.0,"),
                "Bad version range wasn't rejected");

        assertThrows(
                IllegalArgumentException.class, () -> rtInfo.isMavenVersion(""), "Bad version range wasn't rejected");

        assertThrows(

 */

package com.google.common.util.concurrent;

import static com.google.common.truth.Truth.assertThat;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static org.junit.Assert.assertThrows;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**

  @CollectionSize.Require(absent = ZERO)
  public void testRemoveAtIndex_unsupported() {
    assertThrows(UnsupportedOperationException.class, () -> getList().remove(0));
    expectUnchanged();
  }

  @ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
  public void testRemoveAtIndex_negative() {
    assertThrows(IndexOutOfBoundsException.class, () -> getList().remove(-1));
    expectUnchanged();
  }