* @param maxSize the maximum allowed size
     * @param fieldName the field name for error reporting
     * @throws IllegalArgumentException if size is invalid
     */
    public static void validateBufferSize(int size, int maxSize, String fieldName) {
        if (size < 0) {
            throw new IllegalArgumentException(fieldName + " size cannot be negative: " + size);
        }
        if (size > maxSize) {

public class TypeParameterTest extends TestCase {

  public <T> void testCaptureTypeParameter() throws Exception {
    TypeVariable<?> variable = new TypeParameter<T>() {}.typeVariable;
    TypeVariable<?> expected =
        TypeParameterTest.class.getDeclaredMethod("testCaptureTypeParameter")
            .getTypeParameters()[0];
    assertEquals(expected, variable);
  }

  public void testConcreteTypeRejected() {

        synonymFile = new SynonymFile("1", file1.getAbsolutePath(), new Date());
    }

    @Override
    public void tearDown() throws Exception {
        file1.delete();
    }
    */

    @Override
    public void setUp() throws Exception {
        super.setUp();
        synonymFile = new SynonymFile("1", "dummy", new Date());
        List<SynonymItem> itemList = new ArrayList<>();

    private static final byte[] TEST_DATA = "testdata".getBytes();
    private static final byte[] EMPTY_DATA = new byte[0];

    @Mock
    private MessageDigest mockMd5;

    @BeforeEach
    void setUp() throws NoSuchAlgorithmException {
        // Mock Crypto.getMD5() to return our mockMd5 instance
        // This requires Mockito 3.4.0+ for MockedStatic

    mock.assertLastMethodCalled("shutdownNow");
    assertEquals(ImmutableList.of(), list);
  }

  public void testExecute() {
    MockExecutor mock = new MockExecutor();
    TestExecutor testExecutor = new TestExecutor(mock);
    testExecutor.execute(doNothing());
    mock.assertLastMethodCalled("execute");
  }

  public void testSubmit() throws InterruptedException, ExecutionException {
    {
      MockExecutor mock = new MockExecutor();

     */
    public void incrementRequestsSent() {
        requestsSent.incrementAndGet();
    }

    /**
     * Increment requests received counter
     */
    public void incrementRequestsReceived() {
        requestsReceived.incrementAndGet();
    }

    /**
     * Increment error counter
     */
    public void incrementErrors() {
        errors.incrementAndGet();
    }

    /**

        @Test
        @DisplayName("returns provided subject")
        void subject_non_null() {
            Subject s = new Subject();
            TestCredentials creds = new TestCredentials("X", false, false, s, false);
            assertSame(s, creds.getSubject());
        }

        @Test
        @DisplayName("allows null subject")
        void subject_null() {

     * @param maxAccessCount The maximum access count.
     */
    public void setMaxAccessCount(final long maxAccessCount) {
        this.maxAccessCount = maxAccessCount;
    }

    /**
     * Adds sitemaps to the thread-local storage.
     * @param sitemaps An array of sitemap URLs.
     */
    public void addSitemaps(final String[] sitemaps) {
        sitemapsLocal.set(sitemaps);
    }

    /**

 */
@GwtCompatible
@NullMarked
public class CountTest extends TestCase {
  public void testGet() {
    assertEquals(20, new Count(20).get());
  }

  public void testGetAndAdd() {
    Count holder = new Count(20);
    assertEquals(20, holder.get());
    holder.add(1);
    assertEquals(21, holder.get());
  }

  public void testAddAndGet() {
    Count holder = new Count(20);
    assertEquals(21, holder.addAndGet(1));

public class MapEqualsTester<K, V> extends AbstractMapTester<K, V> {
  public void testEquals_otherMapWithSameEntries() {
    assertTrue(
        "A Map should equal any other Map containing the same entries.",
        getMap().equals(newHashMap(getSampleEntries())));
  }

  @CollectionSize.Require(absent = CollectionSize.ZERO)
  public void testEquals_otherMapWithDifferentEntries() {