import static java.util.concurrent.Executors.newCachedThreadPool;
import static java.util.concurrent.Executors.newSingleThreadExecutor;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.junit.Assert.assertThrows;

import com.google.common.annotations.GwtIncompatible;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.concurrent.CancellationException;

        return ordinal() <= v.ordinal();
    }

    /**
     * Get the minimum of two dialect versions
     *
     * @param a the first version to compare
     * @param b the second version to compare
     * @return smaller of the two versions
     */
    public static DialectVersion min(final DialectVersion a, final DialectVersion b) {
        if (a.atMost(b)) {
            return a;
        }

   * <a href="https://github.com/google/guava/wiki/CollectionUtilitiesExplained#comparators">{@code
   * Comparators}</a>.
   *
   * @param a first value to compare, returned if less than or equal to b.
   * @param b second value to compare.
   * @throws ClassCastException if the parameters are not <i>mutually comparable</i>.
   * @since 30.0
   */
  public static <T extends Comparable<? super T>> T min(T a, T b) {

        System.arraycopy(file1, 0, buffer, 102, file1.length);

        // Write second FileBothDirectoryInfo at 8 + 104 = 112
        int secondOffset = 112;
        SMBUtil.writeInt4(0, buffer, secondOffset); // NextEntryOffset (0 = last)
        SMBUtil.writeInt4(1, buffer, secondOffset + 4); // FileIndex
        // ... rest of second entry fields (zeros for simplicity)
        for (int i = 8; i < 94; i++) {

import static java.util.concurrent.Executors.newFixedThreadPool;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.NANOSECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import java.time.Duration;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;

        assertEquals(2, used, "Null path should result in command byte + NUL");
        assertEquals(0x04, buffer[0] & 0xFF, "First byte must still be 0x04");
        assertEquals(0, buffer[1], "Second byte must be null terminator");
    }

    @Test
    @DisplayName("writeBytesWireFormat handles empty string gracefully")
    void testWriteEmptyString() {

    ) -> Response:
        response.headers["X-Second"] = "2"
        return response

    @app.get("/")
    def endpoint(response: Annotated[Response, Depends(second_modifier)]):
        return {"status": "ok"}

    client = TestClient(app)
    resp = client.get("/")

    assert resp.status_code == 200
    assert resp.headers.get("X-First") == "1"
    assert resp.headers.get("X-Second") == "2"

func (sys *BucketQuotaSys) Init(objAPI ObjectLayer) {
	bucketStorageCache.InitOnce(10*time.Second,
		cachevalue.Opts{ReturnLastGood: true, NoWait: true},
		func(ctx context.Context) (DataUsageInfo, error) {
			if objAPI == nil {
				return DataUsageInfo{}, errServerNotInitialized
			}
			ctx, done := context.WithTimeout(ctx, 2*time.Second)
			defer done()

			return loadDataUsageFromBackend(ctx, objAPI)
		},
	)
}

		return nil, nil, err
	}

	// Wait up to 10 seconds for disks to come online.
	pools := obj.(*erasureServerPools)
	t := time.Now()
	for _, pool := range pools.serverPools {
		for _, sets := range pool.erasureDisks {
			for _, s := range sets {
				if !s.IsLocal() {
					for !s.IsOnline() {
						time.Sleep(100 * time.Millisecond)
						if time.Since(t) > 10*time.Second {

	t.Run("testStreamRoundtrip", func(t *testing.T) {
		defer timeout(5 * time.Second)()
		testStreamRoundtrip(t, local, remote)
		assertNoActive(t, connRemoteLocal)
		assertNoActive(t, connLocalToRemote)
	})
	t.Run("testStreamCancel", func(t *testing.T) {
		defer timeout(5 * time.Second)()
		testStreamCancel(t, local, remote)
		assertNoActive(t, connRemoteLocal)