// File access constants should fit in lower 16 bits (0x0000FFFF)
            assertTrue(ACE.FILE_READ_DATA <= 0x0000FFFF, "FILE_READ_DATA should fit in lower 16 bits");
            assertTrue(ACE.FILE_WRITE_DATA <= 0x0000FFFF, "FILE_WRITE_DATA should fit in lower 16 bits");
            assertTrue(ACE.FILE_WRITE_ATTRIBUTES <= 0x0000FFFF, "FILE_WRITE_ATTRIBUTES should fit in lower 16 bits");

            }
        }
    }

    @Test
    @DisplayName("Should have resource types with power-of-2 values")
    void testResourceTypeBitPatterns() {
        // Resource types should be powers of 2 for bit flag usage
        int[] types = { SmbConstants.TYPE_FILESYSTEM, SmbConstants.TYPE_WORKGROUP, SmbConstants.TYPE_SERVER, SmbConstants.TYPE_SHARE,

            }
        }
    }

    @Test
    @DisplayName("Test constant values follow bit flag pattern")
    void testConstantsBitFlagPattern() {
        // Most values should be powers of 2 for bit flag usage
        assertTrue(isPowerOfTwo(SecurityInfo.OWNER_SECURITY_INFO));
        assertTrue(isPowerOfTwo(SecurityInfo.GROUP_SECURITY_INFO));
        assertTrue(isPowerOfTwo(SecurityInfo.DACL_SECURITY_INFO));

            // Verify each is a power of 2
            for (int cap : capabilities) {
                assertTrue(isPowerOfTwo(cap), "Capability 0x" + Integer.toHexString(cap) + " should be a power of 2");
            }

            // Verify no overlapping bits
            for (int i = 0; i < capabilities.length; i++) {

        // Encode "TEST" (0x54 0x45 0x53 0x54)
        // T=0x54: upper nibble 0x5->F(0x46), lower nibble 0x4->E(0x45)
        src[1] = 'F';
        src[2] = 'E'; // T
        // E=0x45: upper nibble 0x4->E(0x45), lower nibble 0x5->F(0x46)
        src[3] = 'E';
        src[4] = 'F'; // E
        // S=0x53: upper nibble 0x5->F(0x46), lower nibble 0x3->D(0x44)
        src[5] = 'F';
        src[6] = 'D'; // S

 * extract additional metadata, or perform other transformations during the
 * indexing process.
 *
 * Ingesters are processed in priority order, with lower numbers having higher priority.
 */
public abstract class Ingester {

    /** Priority of this ingester (lower numbers = higher priority) */
    protected int priority = 99;

    /**
     * Default constructor.
     */
    public Ingester() {

 * The factory maintains a sorted collection of ingesters based on their priority
 * and provides methods to add new ingesters and retrieve the current collection.
 *
 * Ingesters are automatically sorted by priority, with lower numbers having higher priority.
 */
public class IngestFactory {
    /** Logger instance for this class */
    private static final Logger logger = LogManager.getLogger(IngestFactory.class);

        String lower = permission.toLowerCase(Locale.ROOT);
        final String aclPrefix;
        if (lower.startsWith(allowPrefix)) {
            lower = lower.substring(allowPrefix.length());
            permission = permission.substring(allowPrefix.length());
            aclPrefix = StringUtil.EMPTY;
        } else if (lower.startsWith(denyPrefix)) {
            lower = lower.substring(denyPrefix.length());

        assertEquals("みかん ﾘﾝｺﾞ", normalizer.normalize("みかん　リンゴ", null));
    }

    public void test_AnyLower() {
        ICUNormalizer normalizer = new ICUNormalizer("Any-Lower");
        assertEquals("abcd", normalizer.normalize("ABCD", null));
    }

    public void test_HalfwidthFullwidth() {
        ICUNormalizer normalizer = new ICUNormalizer("Halfwidth-Fullwidth");

     * We can't instantiate the class with null, so we can't directly test this method's behavior with null.
     * However, the constructor logic `!isCredentialTypeCorrect()` covers this.
     * If `new PacCredentialType(null)` throws, it implies `isCredentialTypeCorrect()` returned false for null.
     */
    @Test
    void testIsCredentialTypeCorrectWithNullData() {