} catch (IOException e) {
                log.warn("Failed to establish RDMA connection: {}", e.getMessage());
                throw e;
            }
        }
    }

    /**
     * Checks if RDMA connection is available.
     *
     * @return true if RDMA connection is active
     */
    public boolean isRdmaConnected() {
        synchronized (connectionLock) {

import org.junit.jupiter.api.extension.AfterEachCallback
import org.junit.jupiter.api.extension.BeforeEachCallback
import org.junit.jupiter.api.extension.ExtensionContext

/**
 * Apply this rule to all tests. It adds additional checks for leaked resources and uncaught
 * exceptions.
 *
 * Use [newClient] as a factory for a OkHttpClient instances. These instances are specifically
 * configured for testing.
 */
class OkHttpClientTestRule :

     * @param maxCacheAge the maximum cache age in milliseconds
     */
    public void setMaxCacheAge(long maxCacheAge) {
        this.maxCacheAge = maxCacheAge;
    }

    /**
     * Checks if directory change notifications are enabled for cache invalidation
     * @return true if change notifications are enabled
     */
    public boolean isNotificationEnabled() {
        return notificationEnabled;
    }

        env:
          POSTGRES_PASSWORD: gorm
          POSTGRES_USER: gorm
          POSTGRES_DB: gorm
          TZ: Asia/Shanghai
        ports:
          - 9920:5432
        # Set health checks to wait until postgres has started
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

    steps:

package main

import (
	"flag"
	"fmt"
	"go/build"
	"internal/testenv"
	"os"
	"path/filepath"
	"slices"
	"strings"
	"sync"
	"testing"
)

var flagCheck = flag.Bool("check", false, "run API checks")

func TestMain(m *testing.M) {
	flag.Parse()
	for _, c := range contexts {
		c.Compiler = build.Default.Compiler
	}
	build.Default.GOROOT = testenv.GOROOT(nil)

	os.Exit(m.Run())
}

var (

            System.setProperty(Constants.FESS_CONFIG_PREFIX + testKey, newValue);

            // Get value again - in real FessConfigImpl it would be cached,
            // but our test implementation always checks system properties
            String value2 = fessConfig.get(testKey);
            // In our test implementation, it will pick up the new value
            assertEquals(newValue, value2);
        } finally {

        assertFalse(
                wagon.getTransferEventSupport().hasTransferListener(transferListener),
                "Transfer listener still registered after putArtifact");
    }

    /**
     * Checks the verification of checksums.
     */
    @Disabled
    @Test
    void testChecksumVerification() throws Exception {
        ArtifactRepositoryPolicy policy = new ArtifactRepositoryPolicy(

* The frontend (running in the user's browser) sends that `username` and `password` to a specific URL in our API (declared with `tokenUrl="token"`).
* The API checks that `username` and `password`, and responds with a "token" (we haven't implemented any of this yet).
    * A "token" is just a string with some content that we can use later to verify this user.

Check this function, it already has type hints:

{* ../../docs_src/python_types/tutorial003.py hl[1] *}

Because the editor knows the types of the variables, you don't only get completion, you also get error checks:

<img src="/img/python-types/image04.png">

Now you know that you have to fix it, convert `age` to a string with `str(age)`:

{* ../../docs_src/python_types/tutorial004.py hl[2] *}

		if !testCase.time.Equal(ctime) {
			t.Errorf("Test case %d, expect to pass but failed. Wanted modTime: %s, got modTime: %s\n", i+1, testCase.time, ctime)
		}
	}
}

// TestListOnlineDisks - checks if listOnlineDisks and outDatedDisks
// are consistent with each other.
func TestListOnlineDisks(t *testing.T) {
	if runtime.GOOS == globalWindowsOSName {
		t.Skip()
	}