@DisplayName("Access constants should be powers of 2")
        void shouldBeValidPowersOfTwo(int constant) {
            assertTrue(constant > 0, "Constant should be positive");
            assertEquals(0, constant & (constant - 1), "Constant should be power of 2: " + Integer.toHexString(constant));
        }

        @ParameterizedTest

  long[] xLongs;
  long[] yLongs;

  int[] constant;

  private static final long NONNEGATIVE_LONG_MASK = 0x7FFFFFFFFFFFFFFFL;

  @BeforeExperiment
  void setUp() {
    Random random = new Random(randomSeed);
    xInts = new int[SAMPLE_SIZE];
    yInts = new int[SAMPLE_SIZE];
    xLongs = new long[SAMPLE_SIZE];
    yLongs = new long[SAMPLE_SIZE];
    constant = new int[SAMPLE_SIZE];

    void testDcerpcFaultInvalidTag() {
        assertEquals(0x1C000006, DcerpcError.DCERPC_FAULT_INVALID_TAG);
    }

    @Test
    @DisplayName("Should verify DCERPC_FAULT_CONTEXT_MISMATCH constant value")
    void testDcerpcFaultContextMismatch() {
        assertEquals(0x1C00001A, DcerpcError.DCERPC_FAULT_CONTEXT_MISMATCH);
    }

    @Test
    @DisplayName("Should verify DCERPC_FAULT_OP_RNG_ERROR constant value")

 */
public interface FileSystemInformation extends Decodable {

    /**
     * SMB information allocation constant.
     */
    byte SMB_INFO_ALLOCATION = -1;

    /**
     * File system size information constant.
     */
    byte FS_SIZE_INFO = 3;
    /**
     * File system full size information constant.
     */
    byte FS_FULL_SIZE_INFO = 7;

    /**
     * Gets the file system information class.
     *

        assertEquals(0x0, AvPair.MsvAvEOL, "MsvAvEOL constant should be 0x0.");
        assertEquals(0x6, AvPair.MsvAvFlags, "MsvAvFlags constant should be 0x6.");
        assertEquals(0x7, AvPair.MsvAvTimestamp, "MsvAvTimestamp constant should be 0x7.");
        assertEquals(0x08, AvPair.MsvAvSingleHost, "MsvAvSingleHost constant should be 0x08.");
        assertEquals(0x09, AvPair.MsvAvTargetName, "MsvAvTargetName constant should be 0x09.");

pkg go/constant, const Bool = 1
pkg go/constant, const Bool Kind
pkg go/constant, const Complex = 5
pkg go/constant, const Complex Kind
pkg go/constant, const Float = 4
pkg go/constant, const Float Kind
pkg go/constant, const Int = 3
pkg go/constant, const Int Kind
pkg go/constant, const String = 2
pkg go/constant, const String Kind
pkg go/constant, const Unknown = 0

     */
    @Test
    void testNoNullRefConstant() {
        assertNotNull(NdrException.NO_NULL_REF, "NO_NULL_REF constant should not be null.");
        assertEquals("ref pointer cannot be null", NdrException.NO_NULL_REF, "NO_NULL_REF constant should have the expected value.");
    }

    /**
     * Test the INVALID_CONFORMANCE static field.

    /** String constant representing boolean true value. */
    public static final String TRUE = "true";

    /** String constant representing boolean false value. */
    public static final String FALSE = "false";

    /** Boolean constant representing true value. */
    public static final Boolean T = true;

    /** Boolean constant representing false value. */

	case 3:
		if p.arch.Family == sys.PPC64 {
			// Special 3-operand jumps.
			// a[1] is a register number expressed as a constant or register value
			target = &a[2]
			prog.From = a[0]
			if a[0].Type != obj.TYPE_CONST {
				// Legacy code may use a plain constant, accept it, and coerce
				// into a constant. E.g:
				//   BC 4,...
				// into
				//   BC $4,...
				prog.From = obj.Addr{
					Type:   obj.TYPE_CONST,

    /**
     * A constant for no transformer.
     */
    public static final String NO_TRANSFORMER = "NONE";

    /**
     * A constant for "false".
     */
    public static final String FALSE = "false";

    /**
     * A constant for "UTF-8".
     */
    public static final String UTF_8 = "UTF-8";

    /**
     * A constant for UTF-8 charset.
     */