// error classes
    /** Success status code */
    public static final int SUCCESS = 0;
    /** Name service error class */
    public static final int ERR_NAM_SRVC = 0x01;
    /** Session service error class */
    public static final int ERR_SSN_SRVC = 0x02;

    // name service error codes
    /** Format error in the name service */
    public static final int FMT_ERR = 0x1;
    /** Server error in the name service */

        protwordsFile.insert(newItem);

        // Verify the item was added
        protwordsFile.reload(null);
        boolean found = false;
        PagingList<ProtwordsItem> list = protwordsFile.selectList(0, 100);
        for (ProtwordsItem item : list) {
            if ("newWord".equals(item.getInput())) {
                found = true;
                break;
            }
        }
        assertTrue(found);

        private final InetAddress address;
        private final int flags;

        /** Flag indicating IPv4 address type */
        public static final int IPV4 = 0x01;
        /** Flag indicating IPv6 address type */
        public static final int IPV6 = 0x02;

        /**
         * Creates a new witness IP address.
         *
         * @param address the IP address
         */

        assertEquals("0 B", format.formatProgress(0L, 0L));
    }

    @Test
    void testProgressedSizeWithSize() {
        FileSizeFormat format = new FileSizeFormat();

        assertEquals("0/800 B", format.formatProgress(0L, 800L));
        assertEquals("400/800 B", format.formatProgress(400L, 800L));
        assertEquals("800 B", format.formatProgress(800L, 800L));

            policyHandle.uuid.clock_seq_hi_and_reserved = (byte) 0x44;
            policyHandle.uuid.clock_seq_low = (byte) 0x55;
            policyHandle.uuid.node = new byte[] { (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04, (byte) 0x05, (byte) 0x06 };

            when(mockNdrBuffer.derive(anyInt())).thenReturn(mockNdrBuffer);

            // When: Encoding the policy handle
            policyHandle.encode(mockNdrBuffer);

        SmbComLockingAndX cmd = new SmbComLockingAndX(cfg);
        // set fields via reflection
        setField(cmd, "fid", 0x1234);
        setField(cmd, "typeOfLock", (byte) 0x05);
        setField(cmd, "newOpLockLevel", (byte) 0x01);
        setField(cmd, "timeout", 3000L);
        // arrays of one lock and one unlock range
        LockingAndXRange lock = new LockingAndXRange(false);

    }

    /**
     * Test constructor with a malformed token.
     */
    @Test
    void testConstructorMalformed() {
        byte[] malformedToken = new byte[] { 0x01, 0x02, 0x03, 0x04 };
        assertThrows(PACDecodingException.class, () -> new KerberosEncData(malformedToken, Collections.emptyMap()));
    }

    /**
     * Test constructor with an unknown field.
     *

    // relative to headerStart
    static final int SETUP_OFFSET = 61;

    static final int DISCONNECT_TID = 0x01;
    static final int ONE_WAY_TRANSACTION = 0x02;

    private int pad;
    private int pad1;
    private boolean parametersDone, dataDone;

    /** Total number of parameter bytes the server is returning */

    color: #0052cc;
    font-weight: 600;
}

.progress-step.completed .step-label {
    color: #00875a;
}

@keyframes step-pulse {
    0%, 100% { box-shadow: 0 0 0 0 rgba(0, 82, 204, 0.4); }
    50% { box-shadow: 0 0 0 8px rgba(0, 82, 204, 0); }
}

.progress-message {
    text-align: center;
    font-size: 0.8125rem;
    color: #0052cc;
    font-weight: 500;
}

     * Inheritance flag: child objects inherit this ACE
     */
    int FLAGS_OBJECT_INHERIT = 0x01;
    /**
     * Inheritance flag: child containers inherit this ACE
     */
    int FLAGS_CONTAINER_INHERIT = 0x02;
    /**
     * Inheritance flag: inheritance stops after one level
     */
    int FLAGS_NO_PROPAGATE = 0x04;
    /**
     * Inheritance flag: ACE applies only to children, not to the object itself
     */