* type.
     *
     * In practice, we are very unlikely to see `null`: The `WeakReference` to the enum constant
     * won't be cleared as long as the enum constant is referenced somewhere, and the enum constant
     * is referenced somewhere for as long as the enum class is loaded. *Maybe in theory* the enum

	MOV	$1234, 0(SP)			// ERROR "constant load must target register"
	MOV	$1234, 8(SP)			// ERROR "constant load must target register"
	MOV	$0, 0(SP)			// ERROR "constant load must target register"
	MOV	$0, 8(SP)			// ERROR "constant load must target register"
	MOV	$1234, 0(SP)			// ERROR "constant load must target register"
	MOV	$1234, 8(SP)			// ERROR "constant load must target register"

     */
    public static final long UNSPECIFIED_SESSIONID = 0xFFFFFFFFFFFFFFFFL;

    /**
     * SMB2 Channel constant for RDMA V1
     * Used in SMB2 READ and WRITE requests to indicate RDMA channel
     */
    public static final int SMB2_CHANNEL_RDMA_V1 = 0x00000001;

    /**
     * SMB2 Channel constant for RDMA V1 invalidate
     * Used to indicate RDMA with invalidation
     */

        assertNull(entries[0].getName());
        assertEquals(8, entries[0].getType()); // TYPE_SHARE constant value

        assertInstanceOf(SmbShareInfo.class, entries[1]);
        assertEquals("valid_share", entries[1].getName());
        assertEquals(8, entries[1].getType()); // TYPE_SHARE constant value
    }

    @Test
    @DisplayName("DCE/RPC flags should be set correctly")
    void testDcerpcFlags() {

    }

    @Test
    @DisplayName("MonotonicClock start time should remain constant")
    void testStartTime() throws InterruptedException {
        Instant start1 = MonotonicClock.start();
        Thread.sleep(10);
        Instant start2 = MonotonicClock.start();

        assertEquals(start1, start2, "Start time should remain constant");
        assertNotNull(start1, "Start time should not be null");
    }

    @Nested

        @DisplayName("Should have correct FS_SIZE_INFO constant value")
        void testFsSizeInfoConstant() {
            assertEquals((byte) 3, FileSystemInformation.FS_SIZE_INFO);
        }

        @Test
        @DisplayName("Should have correct FS_FULL_SIZE_INFO constant value")
        void testFsFullSizeInfoConstant() {
            assertEquals((byte) 7, FileSystemInformation.FS_FULL_SIZE_INFO);
        }

        @Test

    /**
     * Share type constant for disk shares (file shares).
     */
    public static final byte SMB2_SHARE_TYPE_DISK = 0x1;
    /**
     * Share type constant for named pipe shares (IPC).
     */
    public static final byte SMB2_SHARE_TYPE_PIPE = 0x2;
    /**
     * Share type constant for printer shares.
     */
    public static final byte SMB2_SHARE_TYPE_PRINT = 0x3;

            auth2.close();
            auth3.close();
        }
    }

    /**
     * Test that the constant-time comparison method is actually used internally.
     */
    @Test
    public void testConstantTimeMethodExists() throws Exception {
        // Use reflection to verify the constant-time method exists

	case "BC", "BCL", "BEQ", "BGE", "BGT", "BL", "BLE", "BLT", "BNE", "BR", "BVC", "BVS", "BDNZ", "BDZ", "CALL", "JMP":
		return true
	}
	return false
}

// IsPPC64CMP reports whether the op (as defined by an ppc64.A* constant) is
// one of the CMP instructions that require special handling.
func IsPPC64CMP(op obj.As) bool {
	switch op {

}

// IsARM64ADR reports whether the op (as defined by an arm64.A* constant) is
// one of the comparison instructions that require special handling.
func IsARM64ADR(op obj.As) bool {
	switch op {
	case arm64.AADR, arm64.AADRP:
		return true
	}
	return false
}

// IsARM64CMP reports whether the op (as defined by an arm64.A* constant) is
// one of the comparison instructions that require special handling.