connection.calls.add(CallReference(this, callStackTrace))
  }

  /**
   * Releases resources held with the request or response of [exchange]. This should be called when
   * the request completes normally or when it fails due to an exception, in which case [e] should
   * be non-null.
   *
   * If the exchange was canceled or timed out, this will wrap [e] in an exception that provides

		// side-channel check has failed, we shall take
		// the client offline in such situations.
		// generally all implementations should simply return
		// 403, but in situations where there is a dependency
		// with the caller to take the client offline purpose
		// fully it should make sure to respond with '412'
		// instead, see cmd/storage-rest-server.go for ideas.

    val oldDelegate = timeout.delegate
    timeout.setDelegate(Timeout.NONE)
    oldDelegate.clearDeadline()
    oldDelegate.clearTimeout()
  }

  /**
   * The response body from a CONNECT should be empty, but if it is not then we should consume it
   * before proceeding.
   */
  fun skipConnectBody(response: Response) {
    val contentLength = response.headersContentLength()
    if (contentLength == -1L) return

    @DisplayName("Test with negative FID value (should handle as unsigned)")
    void testNegativeFidValue() {
        int fid = -1; // Will be treated as 0xFFFF in unsigned 16-bit
        notifyChange = new NtTransNotifyChange(mockConfig, fid, FILE_NOTIFY_CHANGE_FILE_NAME, false);
        byte[] dst = new byte[10];

        notifyChange.writeSetupWireFormat(dst, 0);

        // Should write as 0xFFFF (65535 in unsigned)

        assertTrue(seven.compareTo(lowerCaseC) > 0, "expected 7 > c");
        assertTrue(lowerCaseC.compareTo(seven) < 0, "expected c < 7");
    }

    @Test
    void testNonAsciiDigits() { // These should not be treated as digits.
        ComparableVersion asciiOne = new ComparableVersion("1");
        ComparableVersion arabicEight = new ComparableVersion("\u0668");
        ComparableVersion asciiNine = new ComparableVersion("9");

// The returned string is heap-allocated, and caller should call free() on it.
TF_CAPI_EXPORT extern const char* TF_GraphDebugString(TF_Graph* graph,
                                                      size_t* len);

// Returns the function content in a human-readable format, with length set in
// `len`. The format is subject to change in the future.
// The returned string is heap-allocated, and caller should call free() on it.
//

                // No-op
            }
        };

        // Initial execution time should be 0
        assertEquals(0L, callback.getExecuteTime());

        // Store a document
        callback.store(new DataStoreParams(), new HashMap<>());

        // Execution time should be greater than 0
        assertTrue(callback.getExecuteTime() >= 10L);
    }

    @Test

    AtomicBoolean setUpRan = new AtomicBoolean();
    Runnable setUp =
        () ->
            assertFalse("previous tearDown should have run before setUp", setUpRan.getAndSet(true));
    Runnable tearDown = () -> assertTrue("setUp should have run", setUpRan.getAndSet(false));
    return MapTestSuiteBuilder.using(new CheckSetUpHashMapGenerator(setUpRan))
        .named("setUpTearDown")
        .withFeatures(

         */
        public long getNextRetryTime() {
            return nextRetryTime;
        }

        /**
         * Check if recovery should be attempted
         *
         * @return true if should retry
         */
        public boolean shouldRetry() {
            return retryCount < 3;
        }

        /**
         * Increment retry count and update next retry time

		closeBitrotReaders(readers)
		closeBitrotWriters(staleWriters)
		if err != nil && !test.shouldFail {
			t.Errorf("Test %d: should pass but it failed with: %v", i, err)
		}
		if err == nil && test.shouldFail {
			t.Errorf("Test %d: should fail but it passed", i)
		}
		if err == nil {
			// Verify that checksums of staleDisks
			// match expected values
			for i := range staleWriters {