*/

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;

/**

    Set<Integer> nodes = network.nodes();
    assertThrows(UnsupportedOperationException.class, () -> nodes.add(N2));
    addNode(N1);
    assertThat(network.nodes()).containsExactlyElementsIn(nodes);
  }

  @Override
  @Test
  public void edges_checkReturnedSetMutability() {
    Set<String> edges = network.edges();
    assertThrows(UnsupportedOperationException.class, () -> edges.add(E12));

    String test = "abc" + Character.MIN_HIGH_SURROGATE;
    assertThrows(IllegalArgumentException.class, () -> escapeAsString(NOP_ESCAPER, test));
    assertThrows(IllegalArgumentException.class, () -> escapeAsString(SIMPLE_ESCAPER, test));
  }

  public void testNullInput() {
    UnicodeEscaper e = SIMPLE_ESCAPER;
    assertThrows(NullPointerException.class, () -> e.escape((String) null));
  }

    String test = "abc" + Character.MIN_HIGH_SURROGATE;
    assertThrows(IllegalArgumentException.class, () -> escapeAsString(NOP_ESCAPER, test));
    assertThrows(IllegalArgumentException.class, () -> escapeAsString(SIMPLE_ESCAPER, test));
  }

  public void testNullInput() {
    UnicodeEscaper e = SIMPLE_ESCAPER;
    assertThrows(NullPointerException.class, () -> e.escape((String) null));
  }

  @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();
  }

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.when;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

    assertEquals(-1, iterator.previousIndex());
    assertThrows(NoSuchElementException.class, () -> iterator.next());
    assertThrows(NoSuchElementException.class, () -> iterator.previous());
    assertThrows(UnsupportedOperationException.class, () -> iterator.remove());
    assertThrows(UnsupportedOperationException.class, () -> iterator.set("a"));
    assertThrows(UnsupportedOperationException.class, () -> iterator.add("a"));
  }

  }

  public void testSampleVariance() {
    assertThrows(IllegalStateException.class, () -> emptyAccumulator.sampleVariance());
    assertThrows(
        IllegalStateException.class, () -> emptyAccumulatorByAddAllEmptyIterable.sampleVariance());
    assertThrows(
        IllegalStateException.class, () -> emptyAccumulatorByAddAllEmptyStats.sampleVariance());

import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;

    assertThrows(IllegalArgumentException.class, () -> HashCode.fromString(""));
    assertThrows(IllegalArgumentException.class, () -> HashCode.fromString("7"));
    HashCode unused = HashCode.fromString("7f");
  }

  public void testFromStringFailsWithOddLengthInput() {
    assertThrows(IllegalArgumentException.class, () -> HashCode.fromString("7f8"));
  }

  public void testIntWriteBytesTo() {