}{
		{"", "", true},
		{"-1", "0", true},
		{"-1", "900", true},
		{"1574812326", "900", false},
		{1574812326, "900", false},
		{int64(1574812326), "900", false},
		{int(1574812326), "900", false},
		{uint(1574812326), "900", false},
		{uint64(1574812326), "900", false},
		{json.Number("1574812326"), "900", false},
		{1574812326.000, "900", false},
		{time.Duration(3) * time.Minute, "900", false},
	}

        Trans2QueryFSInformationResponse.SmbInfoAllocation info = response.new SmbInfoAllocation();
        info.alloc = 1000;
        info.free = 500;
        info.sectPerAlloc = 100;
        info.bytesPerSect = 512;

        String infoString = info.toString();
        assertTrue(infoString.contains("alloc=1000"), "toString should contain alloc");
        assertTrue(infoString.contains("free=500"), "toString should contain free");

	export MINIO_ROOT_USER=$ACCESS_KEY
	export MINIO_ROOT_PASSWORD=$SECRET_KEY
	export MINIO_ENDPOINTS="http://[::1]:9000${WORK_DIR}/pool-disk-sets-ipv6{1...4} http://[::1]:9001${WORK_DIR}/pool-disk-sets-ipv6{5...8}"
	"${MINIO[@]}" server --address="[::1]:9000" >"$WORK_DIR/pool-minio-ipv6-9000.log" 2>&1 &
	"${MINIO[@]}" server --address="[::1]:9001" >"$WORK_DIR/pool-minio-ipv6-9001.log" 2>&1 &

	"${WORK_DIR}/mc" ready verify_ipv6
}

    stopwatch.start();
    assertEquals("0.000 ns", stopwatch.toString());
    ticker.advance(1);
    assertEquals("1.000 ns", stopwatch.toString());
    ticker.advance(998);
    assertEquals("999.0 ns", stopwatch.toString());
    ticker.advance(1);
    assertEquals("1.000 \u03bcs", stopwatch.toString());
    ticker.advance(1);
    assertEquals("1.001 \u03bcs", stopwatch.toString());
    ticker.advance(8998);

        assertFalse(loopback.isUsableForChannel());
    }

    @Test
    void testGetScore() {
        NetworkInterfaceInfo basic = new NetworkInterfaceInfo(testAddress, 1000);
        assertEquals(1000, basic.getScore()); // Base score is link speed

        NetworkInterfaceInfo fast = new NetworkInterfaceInfo(testAddress, 10000);
        assertTrue(fast.getScore() > basic.getScore());
    }

    @Test

    [
        ("-1", 200),
        ("inf", 200),
        ("-inf", 200),
        ("nan", 200),
        ("0", 200),
        ("342", 200),
    ],
)
def test_allow_inf_nan_param_default(value: str, code: int):
    response = client.post(f"/?z={value}")
    assert response.status_code == code, response.text


@pytest.mark.parametrize(
    "value,code",
    [
        ("-1", 200),
        ("inf", 422),

@pytest.mark.parametrize(
    "path,expected_response",
    [
        (
            "/items/0?q=&size=0.1",
            {"item_id": 0, "size": 0.1},
        ),
        (
            "/items/1000?q=somequery&size=10.4",
            {"item_id": 1000, "q": "somequery", "size": 10.4},
        ),
    ],
)
def test_read_items(client: TestClient, path, expected_response):
    response = client.get(path)

    /** Token (word) to be added to the dictionary */
    @Required
    @Size(max = 1000)
    public String token;

    /** Segmentation information for the token */
    @Required
    @Size(max = 1000)
    public String segmentation;

    /** Reading (pronunciation) of the token in katakana */
    @Required
    @Size(max = 1000)
    public String reading;

    /** Part of speech tag for the token */
    @Required

        smbAuthentication = new SmbAuthentication();
        smbAuthentication.setServer("hoge");
        smbAuthentication.setPort(1000);
        assertEquals("smb1://hoge:1000/", smbAuthentication.getPathPrefix());

        smbAuthentication = new SmbAuthentication();
        smbAuthentication.setPort(1000);
        assertEquals("smb1://", smbAuthentication.getPathPrefix());
    }

    public Integer crudMode;

    /**
     * The regular expression pattern to match request paths.
     */
    @Required
    @Size(max = 1000)
    public String regex;

    /**
     * The replacement pattern for matched paths.
     */
    @Size(max = 1000)
    public String replacement;

    /**
     * The processing type for path mapping.
     */
    @Required
    public String processType;