assertNull(languageHelper.getSupportedLanguage(" ja "));
        assertNull(languageHelper.getSupportedLanguage("ja "));
        assertNull(languageHelper.getSupportedLanguage(" ja"));
    }

    // Mock classes
    private static class MockFessConfig extends FessConfig.SimpleImpl {
        private static final long serialVersionUID = 1L;

        @Override
        public String[] getIndexerLanguageFieldsAsArray() {

        RelatedContent entity = new RelatedContent();
        entity.setTerm(term);
        entity.setContent(content);
        entity.setVirtualHost(virtualHost);
        return entity;
    }

    // Mock classes

    static class MockRelatedContentBhv extends RelatedContentBhv {
        private List<RelatedContent> testData = new ArrayList<>();

        public void setTestData(List<RelatedContent> testData) {

                testRequest.encode(buffer, 0);
            });

            assertTrue(exception.getMessage().contains("Wrong size calculation"));
        }
    }

    // Test implementation classes
    private static class TestServerMessageBlock2Request extends ServerMessageBlock2Request<TestServerMessageBlock2Response> {
        private TestServerMessageBlock2Response testResponse;
        private int testSize = 64;

    // not supported by Android because the underlying implementation from
    // harmony follows the definition from rfc 1034 page 10 for alternative
    // subject names. This causes the code to drop all alternative subjects.
    assertThat(verifier.verify("bar.com", session)).isTrue()
    assertThat(verifier.verify("a.bar.com", session)).isFalse()

 * fingerprint at 4.0 microseconds and md5 at 4.5 microseconds.
 *
 * <p>Note to maintainers: This implementation relies on signed arithmetic being bit-wise equivalent
 * to unsigned arithmetic in all cases except:
 *
 * <ul>
 *   <li>comparisons (signed values can be negative)
 *   <li>division (avoided here)
 *   <li>shifting (right shift must be unsigned)
 * </ul>
 *

import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

import org.junit.jupiter.api.Test;

/**
 * Security-focused test cases for BufferCache to verify buffer overflow protection.
 */
public class BufferCacheSecurityTest {

    /**
     * Test that buffer allocation validates size to prevent overflow.
     */
    @Test

import static java.util.Objects.requireNonNull;

/**
 * Factory methods for creating different types of sources.
 * <p>
 * This class provides specialized source implementations for different use cases:
 * <ul>
 *   <li>Path sources - simple access to file content</li>
 *   <li>Build sources - POM files being actively built by Maven</li>
 *   <li>Resolved sources - POMs resolved from repositories</li>
 * </ul>
 *

        UnsupportedOperationException ex = assertThrows(UnsupportedOperationException.class, iterator::remove);
        assertEquals("Not supported", ex.getMessage());
    }

    @Test
    @DisplayName("Null delegate causes NPE")
    void nullDelegate() {
        assertThrows(NullPointerException.class, () -> {
            new FileEntryAdapterIterator(parent, null, null) {
                @Override

        RelatedQuery entity = new RelatedQuery();
        entity.setTerm(term);
        entity.setQueries(queries);
        entity.setVirtualHost(virtualHost);
        return entity;
    }

    // Mock classes

    static class MockRelatedQueryBhv extends RelatedQueryBhv {
        private List<RelatedQuery> testData = new ArrayList<>();

        public void setTestData(List<RelatedQuery> testData) {

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ConcurrentSkipListMap;
import org.jspecify.annotations.NullUnmarked;

/**
 * Helper classes for various benchmarks.
 *
 * @author Christopher Swenson
 */
@NullUnmarked
final class BenchmarkHelpers {
  /** So far, this is the best way to test various implementations of {@link Set} subclasses. */