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

	driveTimeoutErrorsMD = NewCounterMD(driveTimeoutErrorsTotal,
		"Total timeout errors on a drive", allDriveLabels...)
	driveIOErrorsMD = NewCounterMD(driveIOErrorsTotal,
		"Total I/O errors on a drive", allDriveLabels...)
	driveAvailabilityErrorsMD = NewCounterMD(driveAvailabilityErrorsTotal,
		"Total availability errors (I/O errors, timeouts) on a drive",
		allDriveLabels...)
	driveWaitingIOMD = NewGaugeMD(driveWaitingIO,

        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

	}
	if cache.status == scanStateSuccess || cache.status == scanStateStarted {
		if time.Since(cache.lastUpdate) > metacacheMaxRunningAge {
			// We got a stale entry, mark error on handling server.
			err := fmt.Errorf("timeout: list %s not updated", cache.id)
			cache.error = err.Error()
			cache.status = scanStateError
			rpc.UpdateMetacacheListing(ctx, cache)
			return err
		}
		return nil
	}
	if cache.error != "" {

      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(

            try {
                final boolean isTimeout = !latch.await(time, unit);
                if (isTimeout) {
                    throw new SuggesterException("Request timeout. time:" + time + " unit:" + unit.name());
                }
                if (error != null) {
                    throw new SuggesterException("An error occurred during the deferred computation.", error);
                }

        this.name = "\\PIPE\\LANMAN";

        this.maxParameterCount = 8;
        this.maxDataCount = 16384;
        this.maxSetupCount = (byte) 0x00;
        this.setupCount = 0;
        this.timeout = 5000;
    }

    @Override
    public void reset(final int key, final String lastN) {
        super.reset();
        this.lastName = lastN;
    }

    @Override

	"${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

	# Wait for all drives to be online and formatted
	while [ $(/tmp/mc admin info --json myminio | jq '.info.servers[].drives[].state | select(. != "ok")' | wc -l) -gt 0 ]; do sleep 1; done

    }
    
    private void checkHeartbeats() {
        long timeout = context.getConfig().getWitnessHeartbeatTimeout();
        
        for (WitnessRegistration registration : registrations.values()) {
            if (registration.isExpired(timeout)) {
                log.warn("Witness registration expired: {}", registration.getRegistrationId());
                

							() => {
								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),
						));