}
        return indexName;
    }

    @Override
    protected <RESULT extends Group> RESULT createEntity(final Map<String, Object> source, final Class<? extends RESULT> entityType) {
        try {
            final RESULT result = entityType.newInstance();
            result.setName(DfTypeUtil.toString(source.get("name")));

    @Override
    public void acceptPrimaryKeyMap(Entity entity, Map<String, ? extends Object> primaryKeyMap) {
    }

    @Override
    public void acceptAllColumnMap(Entity entity, Map<String, ? extends Object> allColumnMap) {
    }

    @Override
    public Map<String, Object> extractPrimaryKeyMap(Entity entity) {
        return null;
    }

/**
 * Implementation of {@link Multimaps#filterEntries(SetMultimap, Predicate)}.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
final class FilteredEntrySetMultimap<K extends @Nullable Object, V extends @Nullable Object>
    extends FilteredEntryMultimap<K, V> implements FilteredSetMultimap<K, V> {

  FilteredEntrySetMultimap(SetMultimap<K, V> unfiltered, Predicate<? super Entry<K, V>> predicate) {
    super(unfiltered, predicate);

@GwtCompatible
@NullMarked
public abstract class IteratorTester<E extends @Nullable Object>
    extends AbstractIteratorTester<E, Iterator<E>> {
  /**
   * Creates an IteratorTester.
   *
   * @param steps how many operations to test for each tested pair of iterators
   * @param features the features supported by the iterator
   */
  protected IteratorTester(
      int steps,
      Iterable<? extends IteratorFeature> features,

import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * A class to facilitate the set returned by {@link Graph#edges()}.
 *
 * @author James Sexton
 */
abstract class EndpointPairIterator<N> extends AbstractIterator<EndpointPair<N>> {
  private final BaseGraph<N> graph;
  private final Iterator<N> nodeIterator;

  @Nullable N node = null; // null is safe as an initial value because graphs don't allow null nodes

import org.jspecify.annotations.NullUnmarked;

/**
 * Unit tests for {@link AbstractPackageSanityTests}.
 *
 * @author Ben Yu
 */
@NullUnmarked
public class AbstractPackageSanityTestsTest extends TestCase {
  /*
   * This is a public type so that the Android test runner can create an instance directly as it
   * insists upon doing. It then runs the test, which behaves exactly like this package's existing

import com.google.common.util.concurrent.internal.InternalFutureFailureAccess;
import org.jspecify.annotations.Nullable;

abstract class AbstractFutureState<V extends @Nullable Object> extends InternalFutureFailureAccess
    implements ListenableFuture<V> {
  final boolean casListeners(@Nullable Listener expect, Listener update) {
    if (listeners == expect) {
      listeners = update;

 * A list iterator that does not support {@link #remove}, {@link #add}, or {@link #set}.
 *
 * @since 7.0
 * @author Louis Wasserman
 */
@GwtCompatible
public abstract class UnmodifiableListIterator<E extends @Nullable Object>
    extends UnmodifiableIterator<E> implements ListIterator<E> {
  /** Constructor for use by subclasses. */
  protected UnmodifiableListIterator() {}

  /**

import java.io.OutputStream;
import org.jspecify.annotations.NullUnmarked;

/**
 * A byte sink for testing that has configurable behavior.
 *
 * @author Colin Decker
 */
@NullUnmarked
public class TestByteSink extends ByteSink implements TestStreamSupplier {

  private final ByteArrayOutputStream bytes = new ByteArrayOutputStream();
  private final ImmutableSet<TestOption> options;

  private boolean outputStreamOpened;

    public void testClose_noThrowIOException() throws Exception {
        final OutputStream out = new IOExceptionOccurOutputStream();
        CloseableUtil.close(out);
    }

    private static class NotifyOutputStream extends OutputStream {
        private String notify_;

        @Override
        public void write(final int arg0) throws IOException {
        }

        @Override
        public void close() throws IOException {