* that this will suffice. I have not even benchmarked with different size limits.
         */
        if (validClasses.size() > 1000) {
          validClasses.clear();
        }

        validClasses.add(new WeakReference<Class<? extends Exception>>(exceptionClass));
      }
    }

    /**

	for i := 0; i < 2+numReaders; i++ {
		<-cdone
	}
}

// Borrowed from rwmutex_test.go
func TestRWMutex(t *testing.T) {
	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(-1))
	n := 1000
	if testing.Short() {
		n = 5
	}
	HammerRWMutex(1, 1, n)
	HammerRWMutex(1, 3, n)
	HammerRWMutex(1, 10, n)
	HammerRWMutex(4, 1, n)
	HammerRWMutex(4, 3, n)
	HammerRWMutex(4, 10, n)

    // Check the first 100,000 integers
    for (int i = 0; i < 100000; i++) {
      assertEquals(LongMath.isPrime(i), IntMath.isPrime(i));
    }

    // Then check 1000 deterministic pseudo-random int values.
    Random rand = new Random(1);
    for (int i = 0; i < 1000; i++) {
      int n = rand.nextInt(Integer.MAX_VALUE);
      assertEquals(LongMath.isPrime(n), IntMath.isPrime(n));
    }
  }

     *
     * @return lease timeout in milliseconds
     * @since 2.2
     */
    int getLeaseTimeout();

    /**
     * Property {@code jcifs.smb.client.maxLeases} (int, default 1000)
     *
     * @return maximum number of concurrent leases
     * @since 2.2
     */
    int getMaxLeases();

    /**
     * Property {@code jcifs.smb.client.leaseVersion} (int, default 2)
     *

    executorService =
        new ThreadPoolExecutor(
            NUM_THREADS,
            NUM_THREADS,
            Long.MAX_VALUE,
            SECONDS,
            new ArrayBlockingQueue<Runnable>(1000));
    executorService.prestartAllCoreThreads();
    AtomicInteger integer = new AtomicInteger();
    // Execute a bunch of tasks to ensure that our threads are allocated and hot

    private final int maxAnalyzedContentLength;

    /**
     * Constructor.
     */
    public DefaultContentsParser() {
        maxAnalyzedContentLength = Integer.getInteger("fess.suggest.max.analyzed.content.length", 1000);
    }

    @Override
    public SuggestItem parseSearchWords(final String[] words, final String[][] readings, final String[] fields, final String[] tags,

    /**
     * Test isSearchField() performance with large field set.
     */
    @Test
    public void test_isSearchField_performance() {
        // Create a large set of search fields
        int fieldCount = 1000;
        String[] fields = new String[fieldCount];
        for (int i = 0; i < fieldCount; i++) {
            fields[i] = "field" + i;
        }
        queryFieldConfig.setSearchFields(fields);

        assertSame(specificHandle, handleField.get(lookupSids));
    }

    @Test
    void constructor_shouldHandleLargeSidArray() {
        // Arrange
        int largeSize = 1000;
        testSids = new jcifs.SID[largeSize];
        for (int i = 0; i < largeSize; i++) {
            testSids[i] = mock(jcifs.SID.class);
            when(testSids[i].unwrap(sid_t.class)).thenReturn(mockSidT);

        // Arrange
        transPeekNamedPipe = new TransPeekNamedPipe(mockConfig, TEST_PIPE_NAME, TEST_FID);
        byte[] smallBuffer = new byte[1];
        byte[] largeBuffer = new byte[1000];

        // Act & Assert
        assertEquals(0, transPeekNamedPipe.readSetupWireFormat(smallBuffer, 0, 1));
        assertEquals(0, transPeekNamedPipe.readSetupWireFormat(largeBuffer, 500, 500));

        trans2FindNext2 = new Trans2FindNext2(config, TEST_SID, TEST_RESUME_KEY, TEST_FILENAME, TEST_BATCH_COUNT, TEST_BATCH_SIZE);

        for (int i = 1; i <= 5; i++) {
            int newResumeKey = i * 1000;
            String newFilename = "file" + i + ".txt";

            trans2FindNext2.reset(newResumeKey, newFilename);

            byte[] buffer = new byte[256];