testUser.setRoleNames(new String[] {});
        assertFalse(fessUserBean.hasRole("admin"));

        // Test with single role - matching
        testUser.setRoleNames(new String[] { "admin" });
        assertTrue(fessUserBean.hasRole("admin"));

        // Test with single role - not matching
        assertFalse(fessUserBean.hasRole("user"));

        // Test with multiple roles

    @Test
    public void test_putResultDataBody_withObjectArray() {
        TestFessTransformer transformer = new TestFessTransformer();
        Map<String, Object> dataMap = new HashMap<>();

        // First add a single value
        transformer.putResultDataBody(dataMap, "key1", "value1");
        assertEquals("value1", dataMap.get("key1"));

        // Add an array - should merge with existing value

        // In XML, a single backslash is passed directly (no Java string escaping)
        // So we use a literal backslash here to simulate XML-loaded value
        String xmlLoadedPattern = "image/svg" + "\\" + "+xml"; // Simulates XML value: image/svg\+xml

        generator.addCondition("mimetype", xmlLoadedPattern);

        // The condition map should store the pattern with a single backslash

    public void test_insert_noChains() {
        User user = createTestUser("testuser");
        authenticationManager.insert(user);
        // Should not throw exception even with no chains
    }

    // Test insert with single chain
    @Test
    public void test_insert_singleChain() {
        User user = createTestUser("testuser");
        TestAuthenticationChain chain = new TestAuthenticationChain();
        authenticationManager.addChain(chain);

        String value;
        String[] result;

        // Single unquoted value
        value = "single";
        result = KuromojiCSVUtil.parse(value);
        assertEquals(1, result.length);
        assertEquals("single", result[0]);

        // Single quoted value - quotes preserved
        value = "\"single quoted\"";
        result = KuromojiCSVUtil.parse(value);

    }

    @Test
    public void test_getInputsValue_withSingleInput() {
        // Test with single input
        String[] inputs = { "single" };
        CharMappingItem item = new CharMappingItem(1L, inputs, "output");

        assertEquals("single", item.getInputsValue());
    }

    @Test
    public void test_getInputsValue_withNullInputs() {

        String[] roles = { "admin", "user", "manager" };
        FessUser user = new TestFessUser("testuser", roles, new String[] {}, new String[] {});
        assertArrayEquals(roles, user.getRoleNames());

        // Test with single role
        roles = new String[] { "user" };
        user = new TestFessUser("testuser", roles, new String[] {}, new String[] {});
        assertArrayEquals(roles, user.getRoleNames());

        // Test with empty roles

        assertNotNull(valueMethod);
        assertEquals(String[].class, valueMethod.getReturnType());
        assertEquals(0, valueMethod.getParameterCount());
    }

    // Test class with single role
    @Secured({ "ROLE_USER" })
    static class SingleRoleClass {
        public void testMethod() {
        }
    }

    // Test class with multiple roles
    @Secured({ "ROLE_USER", "ROLE_ADMIN" })

import org.opensearch.index.query.QueryBuilder;
import org.opensearch.index.query.QueryBuilders;

/**
 * Job for exporting indexed search documents to the filesystem.
 * Each document is exported as a single file with URL structure mapped to directory structure.
 */
public class IndexExportJob {

    private static final Logger logger = LogManager.getLogger(IndexExportJob.class);

        }
        return new DefaultQueryBuilder(boolQuery);
    }

    /**
     * Builds a match phrase query, with special handling for single CJK characters.
     * For single CJK characters in title or content fields, uses prefix query instead.
     * @param f The field name.
     * @param text The text to search for.
     * @return The appropriate query builder.
     */