}
        return false;
    }

    /**
     * Checks if the password contains at least one special character.
     * A special character is defined as any character that is not a letter, digit, or whitespace.
     *
     * @param password the password to check
     * @return true if the password contains a special character, false otherwise
     */
    protected boolean containsSpecialChar(final String password) {

    public ExecJob logLevel(final String logLevel) {
        this.logLevel = logLevel;
        return this;
    }

    /**
     * Sets the log suffix for this job execution.
     * The suffix is trimmed and whitespace is replaced with underscores.
     *
     * @param logSuffix the suffix to append to log file names
     * @return this ExecJob instance for method chaining
     */

        assertNull(result, "getAnchorSet should return null for blank string");

        result = crawlerThread.getAnchorSet("   ");
        assertNull(result, "getAnchorSet should return null for whitespace string");
    }

    /**
     * Test getAnchorSet with list of URLs
     */
    @Test
    public void test_getAnchorSet_withList() {
        FessCrawlerThread crawlerThread = new FessCrawlerThread();

        item.setNewInput(newSpecialInput);
        assertEquals(newSpecialInput, item.toLineString());
    }

    @Test
    public void test_whitespaceHandling() {
        // Test with various whitespace scenarios
        ProtwordsItem item1 = new ProtwordsItem(1, "  word  ");
        assertEquals("  word  ", item1.getInput());
        assertEquals("  word  ", item1.toLineString());

        corsFilter.doFilter(mockRequest, mockResponse, mockFilterChain);

        assertTrue(mockFilterChain.wasDoFilterCalled());
        assertFalse(corsHandlerFactory.wasGetCalled());
    }

    // Test with whitespace-only Origin header
    @Test
    public void test_doFilter_whitespaceOriginHeader() throws IOException, ServletException {
        mockRequest.setHeader("Origin", "   ");

        ScriptEngine retrieved = scriptEngineFactory.getScriptEngine("test-engine.v1");
        assertNotNull(retrieved);
        assertEquals(engine, retrieved);
    }

    // Test add with whitespace in name
    @Test
    public void test_add_whitespaceInName() {
        TestScriptEngine engine = new TestScriptEngine();
        scriptEngineFactory.add("  test  ", engine);

        assertNull(doc.get("content_ja")); // content field was not present
    }

    @Test
    public void test_getSupportedLanguage_withWhitespace() {
        // Test that whitespace is not trimmed (as per implementation)
        assertNull(languageHelper.getSupportedLanguage(" ja "));
        assertNull(languageHelper.getSupportedLanguage("ja "));

        assertNotNull(result);
        assertTrue(result instanceof MatchAllQueryBuilder);
    }

    @Test
    public void test_execute_withWhitespaceContext() {
        // Test execute with whitespace query string context
        QueryContext context = new QueryContext("   ", false);
        MatchAllDocsQuery query = new MatchAllDocsQuery();
        float boost = 1.0f;

        // Blank fields are handled before Set lookup
        assertFalse(queryFieldConfig.isFacetField(""));
        assertFalse(queryFieldConfig.isFacetField(null));
        assertFalse(queryFieldConfig.isFacetField("   ")); // Whitespace only
    }

    /**
     * Test that updating fields via setter updates both array and Set.
     */
    @Test
    public void test_updateFields_updatesSetAndArray() {
        // Initial setup

                    notAnalyzedFieldSet.add("field2");
                    notAnalyzedFieldSet.add("field3");

                    // Process analyzed fields with empty and whitespace entries
                    String analyzedFields = "  ,  , field1,  , field2  ,  ";
                    if (analyzedFields != null && !analyzedFields.isEmpty()) {