assertEquals(10000, largeStringOpt.get().length());
    }

    // Custom test class for object testing
    private static class CustomTestObject {
        private final String name;
        private final int value;

        public CustomTestObject(String name, int value) {
            this.name = name;
            this.value = value;
        }

        public String getName() {

 * when there is a specific reason to prioritize memory over CPU.
 *
 * @author Louis Wasserman
 */
@GwtIncompatible // not worth using in GWT for now
final class CompactLinkedHashSet<E extends @Nullable Object> extends CompactHashSet<E> {

  /** Creates an empty {@code CompactLinkedHashSet} instance. */
  public static <E extends @Nullable Object> CompactLinkedHashSet<E> create() {

 * when there is a specific reason to prioritize memory over CPU.
 *
 * @author Louis Wasserman
 */
@GwtIncompatible // not worth using in GWT for now
final class CompactLinkedHashSet<E extends @Nullable Object> extends CompactHashSet<E> {

  /** Creates an empty {@code CompactLinkedHashSet} instance. */
  public static <E extends @Nullable Object> CompactLinkedHashSet<E> create() {

 *
 * @author JJ Furman
 */
@NullUnmarked
@GwtIncompatible
@J2ktIncompatible
public class SequentialExecutorTest extends TestCase {

  private static class FakeExecutor implements Executor {
    final Queue<Runnable> tasks = new ArrayDeque<>();

    @Override
    public void execute(Runnable command) {
      tasks.add(command);
    }

    boolean hasNext() {
      return !tasks.isEmpty();
    }

        MockitoAnnotations.openMocks(this);
    }

    /**
     * Test implementation class for AllocInfo interface
     */
    static class TestAllocInfo implements AllocInfo {
        private final long capacity;
        private final long free;
        private byte fileSystemInformationClass = FS_SIZE_INFO;

        TestAllocInfo(long capacity, long free) {
            this.capacity = capacity;
            this.free = free;

		return "", "", s, ErrHeader
	}
	n -= int64(len(nStr) + 1) // convert from index in s to index in rest
	if n <= 0 {
		return "", "", s, ErrHeader
	}

	// Extract everything between the space and the final newline.
	rec, nl, rem := rest[:n-1], rest[n-1:n], rest[n:]
	if nl != "\n" {
		return "", "", s, ErrHeader
	}

	// The first equals separates the key from the value.
	k, v, ok = strings.Cut(rec, "=")

 *
 * @author Zoe Piepmeier
 */
@NullUnmarked
public class HashingOutputStreamTest extends TestCase {
  private Hasher hasher;
  private HashFunction hashFunction;
  private final ByteArrayOutputStream buffer = new ByteArrayOutputStream();

  @SuppressWarnings("DoNotMock")
  @Override
  protected void setUp() throws Exception {
    super.setUp();
    hasher = mock(Hasher.class);

import com.google.common.annotations.GwtCompatible;
import com.google.errorprone.annotations.CanIgnoreReturnValue;

/** Static utility method for unchecked throwing of any {@link Throwable}. */
@GwtCompatible
final class SneakyThrows<T extends Throwable> {
  /**
   * Throws {@code t} as if it were an unchecked {@link Throwable}.
   *
   * <p>This method is useful primarily when we make a reflective call to a method with no {@code

import com.google.common.annotations.GwtCompatible;
import com.google.errorprone.annotations.CanIgnoreReturnValue;

/** Static utility method for unchecked throwing of any {@link Throwable}. */
@GwtCompatible
final class SneakyThrows<T extends Throwable> {
  /**
   * Throws {@code t} as if it were an unchecked {@link Throwable}.
   *
   * <p>This method is useful primarily when we make a reflective call to a method with no {@code

/**
 * Tests for {@link Multisets#immutableEntry}.
 *
 * @author Mike Bostock
 */
@GwtCompatible
@NullMarked
public class MultisetsImmutableEntryTest extends TestCase {
  private static final @Nullable String NE = null;

  private static <E extends @Nullable Object> Entry<E> entry(E element, int count) {
    return Multisets.immutableEntry(element, count);
  }