assertEquals("https://example.com/98.76/test.html", helpUrl);

        getMockRequest().setLocale(Locale.JAPANESE);
        helpUrl = systemHelper.getHelpUrl("https://example.com/{lang}/{version}/test.html");
        // Check if Japanese is actually supported or just use the fallback
        assertTrue(helpUrl.contains("98.76"));

        getMockRequest().setLocale(Locale.ITALIAN);

        // Test with English
        List<AnalyzeToken> tokensEn = analyzer.analyze(text, field, "en");
        assertNotNull(tokensEn);
        assertEquals(2, tokensEn.size());

        // Test with Japanese
        List<AnalyzeToken> tokensJa = analyzer.analyze(text, field, "ja");
        assertNotNull(tokensJa);
        assertEquals(2, tokensJa.size());

        // Test with null language

    @Test
    public void testConvertWithJapaneseText() throws IOException {
        // Test convert with Japanese text
        String text = "テスト";
        String field = "content";

        List<String> results = converter.convert(text, field, "ja");

        assertNotNull(results);
        // Should use Japanese analyzer and transliterator
    }

    @Test

        assertEquals(Locale.ROOT, fessConfig.getQueryLocaleFromName(""));
        assertEquals(Locale.ROOT, fessConfig.getQueryLocaleFromName("ja"));
        assertEquals(Locale.JAPANESE, fessConfig.getQueryLocaleFromName("test_ja"));
        assertEquals(Locale.CHINESE, fessConfig.getQueryLocaleFromName("test_zh"));
        assertEquals(Locale.SIMPLIFIED_CHINESE, fessConfig.getQueryLocaleFromName("test_zh_cn"));

            fail("refresh() should not throw an exception: " + e.getMessage());
        }
    }

    public void test_matchLocale() {
        assertFalse(labelTypeHelper.matchLocale(Locale.ENGLISH, Locale.JAPANESE));
        assertFalse(labelTypeHelper.matchLocale(Locale.SIMPLIFIED_CHINESE, Locale.TRADITIONAL_CHINESE));

        assertTrue(labelTypeHelper.matchLocale(null, Locale.ROOT));

        assertEquals(1, readings.size());
        assertEquals("TEST@#$%123", readings.get(0));
    }

    @Test
    public void testConvertWithJapaneseText() throws IOException {
        // Test convert with Japanese text
        testConverter.setJapaneseMode(true);
        converter.init();
        String text = "東京";
        String field = "content";

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

    }

    @Test
    public void testWithJapaneseCharacters() {
        // Test with Japanese characters
        String word = "日本語テスト";
        float boost = 2.0f;
        List<String> readings = Arrays.asList("ニホンゴテスト");
        List<String> fields = Arrays.asList("content_ja");
        List<String> tags = Arrays.asList("japanese");
        List<String> roles = Arrays.asList("admin");

        // Test with various international characters
        assertEquals("äöü", queryCommand.toLowercaseWildcard("ÄÖÜ"));
        assertEquals("日本語", queryCommand.toLowercaseWildcard("日本語")); // Japanese doesn't change
        assertEquals("test日本語", queryCommand.toLowercaseWildcard("TEST日本語"));
    }

    public void test_getQueryClassName() {
        assertEquals("WildcardQuery", queryCommand.getQueryClassName());

import org.junit.Test;

/**
 * @author higa
 */
public class TimestampConversionUtilTest {

    @Before
    public void setUp() throws Exception {
        LocaleUtil.setDefault(() -> Locale.JAPANESE);
    }

    @After
    public void tearDown() throws Exception {
        LocaleUtil.setDefault(null);
    }

    /**
     * @throws Exception
     */
    //    @Test

        // Verify
        assertTrue(result.isPresent());
        assertEquals(Locale.US, result.get());
    }

    // Test findBusinessLocale with Japanese locale
    public void test_findBusinessLocale_withJapaneseLocale() {
        // Setup mock config
        FessConfig mockConfig = new FessConfig.SimpleImpl() {
            @Override