logger.warn("Failed to load popular words.", e);
        }
        return Collections.emptyList();
    }

    /**
     * Clears all cached popular word lists.
     */
    public void clearCache() {
        cache.invalidateAll();
    }

    /**
     * Generates a cache key based on the provided parameters.
     *
     * @param seed the seed value
     * @param tags array of tags

                } catch (final Exception e) {
                    return null;
                } finally {
                    final GroovyClassLoader loader = groovyShell.getClassLoader();
                    loader.clearCache();
                }
            }

            @Override
            protected String getName() {
                return Constants.DEFAULT_SCRIPT;
            }
        }.register();
    }

                throw new JobProcessingException(out.toString());
            }
            ComponentUtil.getPopularWordHelper().clearCache();
        } catch (final JobProcessingException e) {
            throw e;
        } catch (final Exception e) {
            throw new JobProcessingException("SuggestCreator Process terminated.", e);

                throw new JobProcessingException(out.toString());
            }
            ComponentUtil.getPopularWordHelper().clearCache();
        } catch (final JobProcessingException e) {
            throw e;
        } catch (final Exception e) {
            throw new JobProcessingException("ThumbnailGenerator Process terminated.", e);

        Mockito.when(mockConfig.getSessionLimit()).thenReturn(10);

        // Clear buffer cache for consistent test results
        BufferCache.clearCache();
    }

    /**
     * Test connection pool scalability with concurrent access
     */
    @Test
    public void testConnectionPoolConcurrentPerformance() throws Exception {

        public boolean calibrateCpuLoad() {
            return true;
        }
    }

    private static class MockPopularWordHelper extends PopularWordHelper {
        @Override
        public void clearCache() {
            // Mock implementation
        }
    }

    private static class MockSuggester {
        private MockSuggestIndexer indexer = new MockSuggestIndexer();

            } catch (final Exception e) {
                logger.warn("Failed to restore " + urlQueue, e);
            }
        }));
    }

    /**
     * Clears the cache.
     */
    public void clearCache() {
        sessionCache.clear();
    }

    /**
     * Updates the session ID for all URL queue entries.
     *
     * @param oldSessionId The old session ID.

    }

    /**
     * Refreshes the suggest index.
     */
    public synchronized void refresh() {
        suggester.refresh();
        if (popularWordHelper != null) {
            popularWordHelper.clearCache();
        }
    }

    /**
     * Sets the interval for storing search logs.
     *
     * @param searchStoreInterval The search store interval in minutes.
     */

        } catch (final Exception e) {
            logger.warn("Failed to delete UrlFilter: sessionId={}", sid, e);
        }

        try {
            // clear queue
            urlQueueService.clearCache();
            urlQueueService.delete(sid);
        } catch (final Exception e) {
            logger.warn("Failed to delete UrlQueue: sessionId={}", sid, e);
        }

        try {
            // clear

    // Mock PopularWordHelper implementation
    private class MockPopularWordHelper extends PopularWordHelper {
        private boolean cacheCleared = false;

        @Override
        public void clearCache() {
            cacheCleared = true;
        }

        public boolean isCacheCleared() {
            return cacheCleared;
        }
    }

    // Mock JobExecutor implementation