Class<T> enumClass) {
    synchronized (enumConstantCache) {
      Map<String, WeakReference<? extends Enum<?>>> constants = enumConstantCache.get(enumClass);
      if (constants == null) {
        constants = populateCache(enumClass);
      }
      return constants;
    }
  }

  /**
   * Returns a serializable converter that converts between strings and {@code enum} values of type

    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")

      return count.get();
    }
  }

  static final class ConstantLoader<K, V> extends CacheLoader<K, V> {
    private final V constant;

    ConstantLoader(V constant) {
      this.constant = constant;
    }

    @Override
    public V load(K key) {
      return constant;
    }
  }

  /**
   * Returns a {@code new Object()} for every request, and increments a counter for every request.

 * used in query file system information operations, with constants for information levels.
 *
 * @author mbechler
 */
public interface FileSystemInformation extends Decodable {

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

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

        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.");

  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];

     */
    @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.

literal.
</p>


<h2 id="Constants">Constants</h2>

<p>There are <i>boolean constants</i>,
<i>rune constants</i>,
<i>integer constants</i>,
<i>floating-point constants</i>, <i>complex constants</i>,
and <i>string constants</i>. Rune, integer, floating-point,
and complex constants are
collectively called <i>numeric constants</i>.
</p>

<p>
A constant value is represented by a

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

	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,