}
        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) {

        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);

        assertEquals("/test.log", AdminLogAction.sanitizeFilename(" ../test.log"));
        assertEquals("/test.log", AdminLogAction.sanitizeFilename(".. / .. /test.log"));
        // Whitespace between dots - must be removed before ".." removal
        assertEquals("/test.log", AdminLogAction.sanitizeFilename(". ./test.log"));
        assertEquals("/test.log", AdminLogAction.sanitizeFilename(". . /test.log"));

        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 "));

        assertEquals(emptyMessage, exception.getMessage());
        assertNull(exception.getCause());
    }

    @Test
    public void test_getMessage_withWhitespaceMessage() {
        // Test constructor with whitespace-only message
        String whitespaceMessage = "   ";
        SsoProcessException exception = new SsoProcessException(whitespaceMessage);

        assertEquals(whitespaceMessage, exception.getMessage());

        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;

        // Execute
        String result = pingSearchEngineJob.execute();

        // Assert
        assertEquals("Status of test-cluster is changed to YELLOW.", result);
    }

    // Test with whitespace in notification addresses
    @Test
    public void test_execute_whitespaceInNotificationAddresses() {
        // Setup mock components
        SearchEngineClient searchEngineClient = new SearchEngineClient() {

        // 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

        CharMappingItem item = result.get(0);
        assertEquals(5, item.getInputs().length);
        assertEquals("output", item.getOutput());
    }

    // Test reload with whitespace handling
    @Test
    public void test_reload_whitespaceHandling() throws Exception {
        writeTestFile("  a , b  =>  c  \n");

        PagingList<CharMappingItem> result = charMappingFile.selectList(0, 10);

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

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