}

    @Test
    @DisplayName("Arrays: non-null, same length, and exact contents")
    void arrays_are_well_formed_and_match() {
        // Validate arrays existence and alignment (edge and structure checks)
        assertNotNull(WinError.WINERR_CODES, "WINERR_CODES should not be null");
        assertNotNull(WinError.WINERR_MESSAGES, "WINERR_MESSAGES should not be null");

    /**
     * Rounds up the size to 8-byte alignment.
     *
     * @param size the size to align
     * @return the aligned size
     */
    protected static final int size8(final int size) {
        return size8(size, 0);
    }

    /**
     * Rounds up the size to the specified alignment.
     *
     * @param size the size to align
     * @param align the alignment boundary
     * @return the aligned size

        return (flags & Smb2HandleCapabilities.SMB2_DHANDLE_FLAG_PERSISTENT) != 0;
    }

    @Override
    public int size() {
        // Context header (16) + name length (4) + padding to 8-byte alignment (4) + data (32)
        return 16 + 4 + 4 + STRUCTURE_SIZE;
    }

    @Override
    public int encode(byte[] dst, int dstIndex) {
        int start = dstIndex;

        // Write context header

   * process it; all should produce the same answer, the only difference should be the number of
   * process()/processRemaining() invocations, due to alignment.
   */
  @AndroidIncompatible // slow. TODO(cpovirk): Maybe just reduce iterations under Android.
  public void testExhaustive() throws Exception {

        
        // Data (16 bytes of reserved)
        int dataOffset = offset + 16 + nameLen;
        dataOffset = (dataOffset + 7) & ~7;  // 8-byte alignment
        
        for (int i = 0; i < 16; i++) {
            buffer[dataOffset + i] = 0;
        }
    }
    
    @Override
    public int size() {
        int nameLen = getName().length();

        dstIndex += this.info.encode(dst, dstIndex);

        /* 6 zeros observed with NT */
        SMBUtil.writeInt8(0L, dst, dstIndex);
        dstIndex += 6;

        /*
         * Also observed 4 byte alignment but we stick
         * with the default for jCIFS which is 2
         */

        return dstIndex - start;
    }

    @Override

                    "Time should never go backwards even with rapid successive calls");
        }
    }

    @Test
    @DisplayName("MonotonicClock should maintain reasonable alignment with system time")
    void testSystemTimeAlignment() {
        Instant monotonic = MonotonicClock.now();
        Instant system = Instant.now();

 * Never up-to-date, non-cacheable.
 *
 * AGP major versions are aligned with Gradle major versions.
 * IOW, AGP X.y officially only supports Gradle X.z.
 *
 * This task leverages that alignment to automatically select which
 * versions of AGP we should test.
 */
@UntrackedTask(because = "Not worth tracking")
abstract class UpdateAgpVersions : AbstractVersionsUpdateTask() {

    @get:Internal

        assertArrayEquals(pathBytes, actualPath);
    }

    @Test
    @DisplayName("Should verify size8 alignment calculation")
    void testSize8Alignment() throws Exception {
        // Given - Various path lengths to test alignment
        String[] paths = { "\\\\a\\b", // Short path
                "\\\\server\\share", // Medium path

     */
    protected int writeString(final String str, final byte[] dst, int dstIndex, final boolean unicode) {
        final int start = dstIndex;
        if (unicode) {
            // Unicode requires word alignment
            if ((dstIndex - this.headerStart) % 2 != 0) {
                dst[dstIndex++] = (byte) '\0';
            }
            System.arraycopy(Strings.getUNIBytes(str), 0, dst, dstIndex, str.length() * 2);