// This is expected behavior - the reserved fields are not explicitly written to 0

        // FileId (16 bytes) - should match our test file ID
        byte[] wireFileId = new byte[16];
        System.arraycopy(buffer, 8, wireFileId, 0, 16);
        assertArrayEquals(testFileId, wireFileId);

  @Test
  fun cancelImmediatelyAfterEnqueue() {
    server.enqueue(MockResponse())
    val latch = CountDownLatch(1)
    client =
      client
        .newBuilder()
        .addNetworkInterceptor(
          Interceptor { chain: Interceptor.Chain ->
            try {
              latch.await()
            } catch (e: InterruptedException) {
              throw AssertionError(e)
            }

                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    latch.countDown();
                }
            });
        }

        // Then
        assertTrue(latch.await(10, TimeUnit.SECONDS));
        executor.shutdown();

      return Double.valueOf(input);
    } catch (NumberFormatException e) {
      return null;
    }
  }

  @GwtIncompatible // Doubles.tryParse
  private static void checkTryParse(String input) {
    Double expected = referenceTryParse(input);
    assertThat(Doubles.tryParse(input)).isEqualTo(expected);
    if (expected != null && !Doubles.FLOATING_POINT_PATTERN.matcher(input).matches()) {

                        .status(ApiResult.Status.OK)
                        .result());
    }

    /**
     * Retrieves a specific key match setting by ID.
     *
     * @param id the ID of the key match setting to retrieve
     * @return JSON response containing the key match setting
     */
    // GET /api/admin/keymatch/setting/{id}
    @Execute
    public JsonResponse<ApiResult> get$setting(final String id) {

        for (int i = 4; i < 20; i++) {
            assertEquals(0, aad[i], "Signature bytes should be zero in AAD");
        }

        // Verify nonce matches at position 20
        for (int i = 0; i < 16; i++) {
            assertEquals(testNonce[i], aad[20 + i], "Nonce should match at position " + (20 + i));
        }
    }

    @Test
    @DisplayName("Should create transform header with constructor")

    // If the host exactly matches, we're done: this connection can carry the address.
    if (address.url.host ==
      this
        .route()
        .address.url.host
    ) {
      return true // This connection is a perfect match.
    }

    // At this point we don't have a hostname match. But we still be able to carry the request if

                final int _klen = _key.length();
                boolean match = false;

                if (_klen == key.length()) {
                    match = _key.equals(key);
                } else if (_klen < key.length()) {
                    match = _key.regionMatches(0, key, 0, _klen) && key.charAt(_klen) == '\\';
                }

                if (match) {
                    dr = (DfsReferral) referrals.map.get(_key);

                    // Normal polling interval: max 5 seconds, increased based on failures
                    long pollInterval = Math.min(MAX_POLL_INTERVAL, BASE_POLL_INTERVAL + (registration.getHeartbeatFailures() * 500));
                    Thread.sleep(pollInterval);

                } catch (InterruptedException e) {
                    log.debug("Async notification monitoring interrupted for {}", registrationId);

        when(mockAllocInfo.getFree()).thenReturn(400L);

        assertEquals(1000L, mockAllocInfo.getCapacity(), "capacity should match stubbed value");
        assertEquals(400L, mockAllocInfo.getFree(), "free space should match stubbed value");
        verify(mockAllocInfo, times(1)).getCapacity();
        verify(mockAllocInfo, times(1)).getFree();
    }

    /**