f.Add(b.Bytes())

	f.Fuzz(func(t *testing.T, b []byte) {
		r := NewReader(bytes.NewReader(b))
		type file struct {
			header  *Header
			content []byte
		}
		files := []file{}
		for {
			hdr, err := r.Next()
			if err == io.EOF {
				break
			}
			if err != nil {
				return
			}
			buf := bytes.NewBuffer(nil)
			if _, err := io.Copy(buf, r); err != nil {
				continue
			}

        ConcurrentModificationException.class,
        () -> {
          Iterator<E> iterator = collection.iterator();
          assertTrue(collection.removeIf(Predicate.isEqual(samples.e0())));
          iterator.next();
        });
  }

  @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
  @CollectionSize.Require(ZERO)
  public void testRemoveIf_unsupportedEmptyCollection() {
    try {
      assertFalse(

    assertThrows(
        ConcurrentModificationException.class,
        () -> {
          Iterator<E> iterator = collection.iterator();
          getList().remove(getNumElements() / 2);
          iterator.next();
        });
  }

  @ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
  @CollectionSize.Require(absent = ZERO)
  public void testRemoveAtIndex_last() {
    runRemoveTest(getNumElements() - 1);
  }

        return value;
      }
    };
  }

  private static <K extends @Nullable Object, V extends @Nullable Object> Entry<K, V> control(
      K key, V value) {
    return singletonMap(key, value).entrySet().iterator().next();
  }

  public void testToString() {
    assertThat(entry("foo", 1).toString()).isEqualTo("foo=1");
  }

  public void testToStringNull() {
    assertThat(entry(NK, 1).toString()).isEqualTo("null=1");

		if offset >= int64(len(block)) {
			// Decrement offset.
			offset -= int64(len(block))
			continue
		}

		// Skip until offset.
		block = block[offset:]

		// Reset the offset for next iteration to read everything
		// from subsequent blocks.
		offset = 0

		// We have written all the blocks, write the last remaining block.
		if write < int64(len(block)) {
			n, err := dst.Write(block[:write])

		func(ctx context.Context) (time.Time, error) {
			return time.Now(), nil
		},
	)

	b.ReportAllocs()
	b.ResetTimer()

	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			cache.Get()
		}
	})

    return Multisets.immutableEntry(element, count);
  }

  private static <E extends @Nullable Object> Entry<E> control(E element, int count) {
    return HashMultiset.create(nCopies(count, element)).entrySet().iterator().next();
  }

  public void testToString() {
    assertThat(entry("foo", 1).toString()).isEqualTo("foo");
    assertThat(entry("bar", 2).toString()).isEqualTo("bar x 2");
  }

  public void testToStringNull() {

        vector.add("a");
        final EnumerationIterator<String> itr = new EnumerationIterator<String>(vector.elements());
        assertThat(itr.hasNext(), is(true));
        assertThat(itr.next(), is("a"));
        assertThat(itr.hasNext(), is(not(true)));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testRemove() throws Exception {

@NullUnmarked
public class ContiguousSetTest extends TestCase {
  private static final DiscreteDomain<Integer> NOT_EQUAL_TO_INTEGERS =
      new DiscreteDomain<Integer>() {
        @Override
        public Integer next(Integer value) {
          return integers().next(value);
        }

        @Override
        public Integer previous(Integer value) {
          return integers().previous(value);
        }

        @Override

                // Fall through to next option
            }
        }

        // Check for Commons Logging
        if (isClassAvailable("org.apache.commons.logging.LogFactory")) {
            try {
                return new JclLoggerAdapterFactory();
            } catch (final Throwable ignore) {
                // Fall through to next option
            }
        }