assertEquals("タイトル", doc.get("title_ja"));
        assertNull(doc.get("content_ja")); // content field was not present
    }

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

        assertEquals(5, readings.size()); // Should be limited to 5
    }

    @Test
    public void testConvertWithWhitespace() throws IOException {
        // Test convert with various whitespace
        converter.init();
        String text = "  test  \n\t  text  ";
        String field = "content";

        List<String> readings = converter.convert(text, field, "en");

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

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

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

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

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

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

        final StringBuilder buf = new StringBuilder(searchWord.length());
        char prev = 0;
        for (final char c : searchWord.toCharArray()) {
            if (!Character.isWhitespace(c)) {
                buf.append(c);
            } else if (!Character.isWhitespace(prev)) {
                buf.append(' ');
            }
            prev = c;
        }
        final String[] words = buf.toString().trim().split(" ");

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

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

        corsFilter.doFilter(mockRequest, mockResponse, mockFilterChain);

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

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

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.base;

import static com.google.common.base.CharMatcher.whitespace;
import static org.junit.Assert.assertThrows;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;

        assertNotNull(tokens);
        assertTrue(tokens.isEmpty());
    }

    @Test
    public void testAnalyzeWithWhitespaceOnly() {
        // Test analyze with whitespace only
        String text = "   ";
        String field = "content";
        String lang = "en";

        List<AnalyzeToken> tokens = analyzer.analyze(text, field, lang);

        assertNotNull(tokens);