disown $pid2

	"${MINIO[@]}" --address ":$((start_port + 3))" $args >"${WORK_DIR}/dist-minio-server3.log" 2>&1 &
	pid3=$!
	disown $pid3

	export MC_HOST_myminio="http://minio:minio123@127.0.0.1:$((start_port + 1))"
	timeout 15m /tmp/mc ready myminio || fail

	[ ${first_time} -eq 0 ] && upload_objects
	[ ${first_time} -ne 0 ] && sleep 120

	if ! ps -p $pid1 1>&2 >/dev/null; then
		echo "minio server 1 is not running" && fail
	fi

  public void testTimeoutOnGetWorksCorrectly() throws InterruptedException, ExecutionException {

    // The task thread waits for the latch, so we expect a timeout here.
    try {
      future.get(20, MILLISECONDS);
      fail("Should have timed out trying to get the value.");
    } catch (TimeoutException expected) {
    } finally {
      latch.countDown();
    }
  }

    }

    /**
     * Error categories
     */
    public enum Category {
        AUTHENTICATION, AUTHORIZATION, NETWORK, PROTOCOL, RESOURCE, CONFIGURATION, ENCRYPTION, TIMEOUT, IO, UNKNOWN
    }

    private final int errorCode;
    private final Severity severity;
    private final Category category;
    private final Map<String, Object> context;
    private final long timestamp;

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

    /**
     * Gets the remaining bytes count.
     *
     * @return the remaining
     */
    public final int getRemaining() {
        return this.remaining;
    }

    /**
     * Sets the open timeout value.
     *
     * @param openTimeout
     *            the openTimeout to set
     */
    public final void setOpenTimeout(final int openTimeout) {
        this.openTimeout = openTimeout;
    }

        assertTrue(info.isReconnecting());
    }

    @Test
    public void testGetHandleForReconnectExpired() {
        manager.requestDurableHandle("/test/file.txt", HandleType.DURABLE_V2, 100, // 100ms timeout
                null);

        // Wait for expiration
        try {
            Thread.sleep(150);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

      return shutdown;
    }

    @Override
    public boolean isTerminated() {
      return shutdown;
    }

    @Override
    public boolean awaitTermination(long timeout, TimeUnit unit) {
      return true;
    }

    @Override
    public void execute(Runnable runnable) {}

    @Override
    public <V> ListenableScheduledFuture<V> schedule(

        uses: gradle/actions/setup-gradle@v4

      - name: Run native-image tests
        run: ./gradlew -PgraalBuild=true native-image-tests:nativeTest

  testandroid:
    runs-on: ubuntu-latest
    timeout-minutes: 30

    strategy:
      fail-fast: false
      matrix:
        api-level:
          - 21
          - 29
          - 34

    steps:
      - name: Checkout

							() => {
								this._resume();
								while (this._scheduledTimeouts.has(id)) {
									// for some reason Go failed to register the timeout event, log and try again
									// (temporary workaround for https://github.com/golang/go/issues/28975)
									console.warn("scheduleTimeoutEvent: missed timeout event");
									this._resume();
								}
							},
							getInt64(sp + 8),
						));