// finishCrawling should be set when max empty list count is exceeded
        // In test environment this may not work as expected
        // assertTrue(indexUpdater.finishCrawling);
        // Thread may still be alive in test environment
        // assertFalse(indexUpdater.isAlive());
    }

    // Test run with max error count exceeded
    @Test
    public void test_run_maxErrorCountExceeded() throws Exception {

public class ResultOffsetExceededExceptionTest extends UnitFessTestCase {

    @Test
    public void test_constructor_withMessage() {
        // Test with normal message
        String message = "Offset exceeded the limit";
        ResultOffsetExceededException exception = new ResultOffsetExceededException(message);

        assertEquals(message, exception.getMessage());
        assertNotNull(exception.getStackTrace());

        } catch (final FileUploadByteCountLimitException e) { // special handling
            handleSizeLimitExceededException(request, e);
        } catch (final FileUploadException e) { // contains fileCount exceeded
            handleFileUploadException(e);
        }
    }

    protected void prepareElementsHash() { // traditional name

        // If the compressed or decompressed length exceeds the limit, don't even bother.
        if (headerListByteCount + length > HEADER_LIMIT) {
          throw IOException("header byte count limit of $HEADER_LIMIT exceeded")
        }

        return if (huffmanDecode) {
          val decodeBuffer = Buffer()
          Huffman.decode(source, length, decodeBuffer)
          decodeBuffer.readByteString()
        } else {

		}
	}
	c.evictList.Init()
}

// Add adds a value to the cache. Returns true if an eviction occurred.
// Returns false if there was no eviction: the item was already in the cache,
// or the size was not exceeded.
func (c *LRU[K, V]) Add(key K, value V) (evicted bool) {
	c.mu.Lock()
	defer c.mu.Unlock()
	now := time.Now()

	// Check for existing item
	if ent, ok := c.items[key]; ok {
		c.evictList.MoveToFront(ent)

        String result = crawlJob.execute();

        assertNotNull(result);
        assertTrue(result.contains("Session Id: " + testSessionId));
    }

    // Test execute method with max processes exceeded
    @Test
    public void test_execute_maxProcessesExceeded() {
        // Setup test
        crawlJob = new CrawlJob() {
            @Override
            protected int getRunningJobCount() {

        String result = pythonJob.execute();

        assertNotNull(result);
        assertTrue(result.contains("Session Id:"));
        assertTrue(result.contains("Process is terminated due to 60 second exceeded") || result.contains("Process terminated"));
    }

    // Test executePython with blank filename
    @Test
    public void test_executePython_blankFilename() {
        pythonJob.filename("");

        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        if (clickLogQueue.size() > fessConfig.getLoggingClickMaxQueueSizeAsInteger()) {
            logger.warn("Click log queue size exceeded: queueSize={}, limit={}. Skipped.", clickLogQueue.size(),
                    fessConfig.getLoggingClickMaxQueueSizeAsInteger());
            return;
        }
        clickLogQueue.add(clickLog);
    }

        }
        try {
            if (!concurrencyLimiter.tryAcquire(getConcurrencyWaitTimeoutMs(), TimeUnit.MILLISECONDS)) {
                logger.warn("[LLM] Concurrency limit exceeded. name={}, maxConcurrent={}, waitTimeout={}ms", getName(),
                        getMaxConcurrentRequests(), getConcurrencyWaitTimeoutMs());

labels.send_testmail=Send Test Mail
labels.backup_configuration=Backup
labels.backup_name=Name
labels.backup_bulk_file=Bulk File
labels.backup_button_upload=Upload
labels.process_time_is_exceeded=The search processing time has exceeded the limit. The displayed results may be partial.
labels.user_given_name=Given Name
labels.givenName=Given Name
labels.user_surname=Surname
labels.surame=Surname
labels.user_mail=Mail
labels.mail=Mail