headers = {"Authorization": f"token {settings.sponsors_token.get_secret_value()}"}
    variables = {"after": after}
    response = httpx.post(
        github_graphql_url,
        headers=headers,
        timeout=settings.httpx_timeout,
        json={"query": query, "variables": variables, "operationName": "Q"},
    )
    if response.status_code != 200:
        logging.error(f"Response was not 200, after: {after}")

  @Override
  public final void awaitRunning(long timeout, TimeUnit unit) throws TimeoutException {
    delegate.awaitRunning(timeout, unit);
  }

  /**
   * @since 15.0
   */
  @Override
  public final void awaitTerminated() {
    delegate.awaitTerminated();
  }

  /**
   * @since 15.0
   */
  @Override
  public final void awaitTerminated(long timeout, TimeUnit unit) throws TimeoutException {

// Call (TestGrid).Cleanup() when done.
func SetupTestGrid(n int) (*TestGrid, error) {
	hosts, listeners, err := getHosts(n)
	if err != nil {
		return nil, err
	}
	dialer := &net.Dialer{
		Timeout: 5 * time.Second,
	}
	var res TestGrid
	res.Hosts = hosts
	ready := make(chan struct{})
	ctx, cancel := context.WithCancel(context.Background())
	res.cancel = cancel
	for i, host := range hosts {

        // Create an expired handle
        HandleInfo expiredHandle = new HandleInfo("/test/file.txt", new HandleGuid(), new byte[16], HandleType.DURABLE_V2, 100, // 100ms timeout
                null);

        // Wait for expiration
        Thread.sleep(150);

        CompletableFuture<HandleInfo> future = reconnector.reconnectHandle(expiredHandle, new IOException("Network error"));

        super(config, SMB_COM_TRANSACTION, TRANS_CALL_NAMED_PIPE);
        this.name = pipeName;
        this.pipeData = data;
        this.pipeDataOff = off;
        this.pipeDataLen = len;
        this.timeout = 0xFFFFFFFF;
        this.maxParameterCount = 0;
        this.maxDataCount = 0xFFFF;
        this.maxSetupCount = (byte) 0x00;
        this.setupCount = 2;
    }

    @Override

        // Test fallback logic
        assertTrue(errorHandler.shouldFallbackToTcp(hardwareError), "Hardware errors should suggest TCP fallback");
        assertFalse(errorHandler.shouldFallbackToTcp(timeoutError), "Timeout errors should not immediately suggest TCP fallback");

        // Test error classification using public API
        assertNotNull(errorHandler, "Error handler should handle network errors");

        when(req.getOverrideTimeout()).thenReturn(1234);

        // Act
        int timeout = transport.getResponseTimeout(req);

        // Assert
        assertEquals(1234, timeout);
    }

    @Test
    @DisplayName("getResponseTimeout falls back to config for non-SMB requests")
    void getResponseTimeout_default() {
        // Arrange

     */
    public void setMaxRetryCount(final int maxRetryCount) {
        this.maxRetryCount = maxRetryCount;
    }

    /**
     * Sets the connection timeout in milliseconds.
     *
     * @param connTimeout The connection timeout.
     */
    public void setConnTimeout(final long connTimeout) {
        this.connTimeout = connTimeout;
    }

    /**

     */
    @Override
    public final Integer getOverrideTimeout() {
        return this.overrideTimeout;
    }

    /**
     * Sets an override timeout for this request.
     *
     * @param overrideTimeout
     *            the overrideTimeout to set
     */
    public final void setOverrideTimeout(final Integer overrideTimeout) {

        assertEquals(16384, netServerEnum2.maxDataCount);
        assertEquals(0, netServerEnum2.maxSetupCount);
        assertEquals(0, netServerEnum2.setupCount);
        assertEquals(5000, netServerEnum2.timeout);
    }

    /**
     * Test the reset method.
     */
    @Test
    void testReset() {
        String lastName = "LAST_NAME";
        netServerEnum2.reset(0, lastName);