thread.start();
    return thread;
  }

  /**
   * Generates a test case verifying that calling any enterXxx, tryEnterXxx, or waitForXxx method
   * with a guard that doesn't match the monitor produces an IllegalMonitorStateException.
   */
  private static TestCase generateGuardWithWrongMonitorTestCase(
      Method method, boolean fair1, boolean fair2) {

    private static final int DEFAULT_HASH_ALGORITHM = HASH_ALGO_SHA512;
    private static final int SALT_SIZE = 32; // 32 bytes as per SMB 3.1.1 spec
    private static final int HASH_SIZE_SHA512 = 64; // SHA-512 produces 64-byte hashes

    // Session-specific preauth integrity contexts
    private final ConcurrentMap<String, PreauthIntegrityContext> sessionContexts = new ConcurrentHashMap<>();

    // Security configuration

    thread.start();
    return thread;
  }

  /**
   * Generates a test case verifying that calling any enterXxx, tryEnterXxx, or waitForXxx method
   * with a guard that doesn't match the monitor produces an IllegalMonitorStateException.
   */
  private static TestCase generateGuardWithWrongMonitorTestCase(
      Method method, boolean fair1, boolean fair2) {

     * AbstractFuture.executeListener to do so, since that method would have the ability to continue
     * to execute other listeners.
     *
     * What about RuntimeException? If there is a bug in set()/setValue() that produces one, it will
     * propagate, too, but only as far as AbstractFuture.executeListener, which will catch and log
     * it.
     */
    setResult(transformResult);
  }

        String result = notifyChange.toString();

        assertNotNull(result);
        // Hexdump.toHexString uses uppercase and produces only the specified width
        // Note: completionFilter is displayed with 4 hex chars, not 8
        assertTrue(result.contains("fid=0x0000"));

        NegTokenInit parsed = new NegTokenInit(token);
        assertEquals(flags, parsed.getContextFlags(), "Context flags should parse from DER BIT STRING");
    }

    @Test
    @DisplayName("Sanity: toByteArray produces APPLICATION class wrapper and valid structure")
    void testToByteArrayStructureSanity() throws Exception {
        NegTokenInit init =

                                                    TF_Status* status);

// Returns the device type of the operation that produced `h`.
TF_CAPI_EXPORT extern const char* TFE_TensorHandleDeviceType(
    TFE_TensorHandle* h, TF_Status* status);

// Returns the device ID of the operation that produced `h`.
TF_CAPI_EXPORT extern int TFE_TensorHandleDeviceID(TFE_TensorHandle* h,

   * @param keyFunction the function used to produce the key for each value
   * @return a map mapping the result of evaluating the function {@code keyFunction} on each value
   *     in the input collection to that value
   * @throws IllegalArgumentException if {@code keyFunction} produces the same key for more than one
   *     value in the input collection

        // The third parameter is the size of the output string in characters
        // size = number of hex characters to output
        // Each byte produces 2 hex characters

        // Test basic conversion (srcIndex is ignored in the implementation)
        byte[] data1 = { 0x00, 0x01, 0x02, 0x03 };
        assertEquals("00", Hexdump.toHexString(data1, 0, 2)); // 2 chars = 1 byte

   * @param keyFunction the function used to produce the key for each value
   * @return a map mapping the result of evaluating the function {@code keyFunction} on each value
   *     in the input collection to that value
   * @throws IllegalArgumentException if {@code keyFunction} produces the same key for more than one
   *     value in the input collection