*
 * @author Louis Wasserman
 */
@NullUnmarked
public class BigIntegerMathBenchmark {
  private static final int[] factorials = new int[ARRAY_SIZE];
  private static final int[] slowFactorials = new int[ARRAY_SIZE];
  private static final int[] binomials = new int[ARRAY_SIZE];

  @Param({"50", "1000", "10000"})
  int factorialBound;

  @BeforeExperiment
  void setUp() {

    }

    @Override
    public Class<?> next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        final Class<?> result = clazz;
        clazz = clazz.getSuperclass();
        return result;
    }

    @Override
    public void remove() {
        throw new ClUnsupportedOperationException("remove");
    }

        byte[] dst = new byte[42];

        // When
        int result = trans2SetFileInformation.writeDataWireFormat(dst, 0);

        // Then
        assertEquals(40, result); // Returns 40 bytes written
    }

    @Test
    void testReadSetupWireFormat() {
        // When
        int result = trans2SetFileInformation.readSetupWireFormat(new byte[0], 0, 0);

        // Then

    List<K> keys = new ArrayList<>(multimap().keySet());
    for (K key : keys) {
      resetCollection();
      assertTrue(multimap().asMap().remove(key) instanceof List);
    }
  }

  @CollectionSize.Require(SEVERAL)
  public void testEquals() {
    resetContainer(mapEntry(k0(), v0()), mapEntry(k1(), v0()), mapEntry(k0(), v3()));
    Map<K, Collection<V>> expected = new HashMap<>();

    List<K> keys = new ArrayList<>(multimap().keySet());
    for (K key : keys) {
      resetCollection();
      assertTrue(multimap().asMap().remove(key) instanceof List);
    }
  }

  @CollectionSize.Require(SEVERAL)
  public void testEquals() {
    resetContainer(mapEntry(k0(), v0()), mapEntry(k1(), v0()), mapEntry(k0(), v3()));
    Map<K, Collection<V>> expected = new HashMap<>();

        lock = new Object();
    }

    @Override
    public int read() throws IOException {
        int result = -1;

        synchronized (lock) {
            try {
                while (used == 0) {
                    lock.wait();
                }
            } catch (final InterruptedException ie) {
                throw new IOException(ie.getMessage());
            }

    @Mock
    Configuration configuration;

    @Mock
    CIFSContext cifsContext;

    // Helper to create a fresh request under test
    private Smb2LogoffRequest newRequest() {
        return new Smb2LogoffRequest(configuration);
    }

    @Test
    @DisplayName("size() returns 8-byte aligned value (header + 4)")
    void size_returnsAlignedValue() {
        // Arrange

  }

  // looking for of() with > 5 entries? Use the builder instead.

  /**
   * Returns a new builder. The generated builder is equivalent to the builder created by the {@link
   * Builder} constructor.
   */
  public static <K, V> Builder<K, V> builder() {
    return new Builder<>();
  }

  /**
   * Returns a new builder with a hint for how many distinct keys are expected to be added. The

        assertNotNull("Target annotation should be present", target);

        final Set<ElementType> expectedTargets = new HashSet<>(Arrays.asList(METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER));
        final Set<ElementType> actualTargets = new HashSet<>(Arrays.asList(target.value()));

        assertEquals("Target elements should match", expectedTargets, actualTargets);
    }

        KeyMatchCQ cq = new KeyMatchCQ();
        if (queryLambda != null) {
            queryLambda.callback(cq);
        }
        FilterAggregationBuilder builder = regFilterA(name, cq.getQuery());
        if (opLambda != null) {
            opLambda.callback(builder);
        }
        if (aggsLambda != null) {
            KeyMatchCA ca = new KeyMatchCA();
            aggsLambda.callback(ca);