@GwtIncompatible
  public Class<K> keyType() {
    return keyTypeOrObjectUnderJ2cl;
  }

  /**
   * @serialData the key class, number of entries, first key, first value, second key, second value,
   *     and so on.
   */
  @GwtIncompatible // java.io.ObjectOutputStream
  private void writeObject(ObjectOutputStream stream) throws IOException {
    stream.defaultWriteObject();

import com.google.common.annotations.GwtIncompatible;
import java.util.concurrent.locks.LockSupport;
import org.jspecify.annotations.Nullable;

/**
 * Works around an android bug, where parking for more than INT_MAX seconds can produce an abort
 * signal on 32 bit devices running Android Q.
 */
@GwtIncompatible
final class OverflowAvoidingLockSupport {
  // Represents the max nanoseconds representable on a linux timespec with a 32 bit tv_sec

        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++) {

        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)
		},
	)
}

	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)

```Python
old_dict = {
    "old key": "old value",
    "second old key": "second old value",
}
new_dict = {**old_dict, "new key": "new value"}
```

ここでは、`new_dict` には `old_dict` のすべてのキーと値に加え、新しいキーと値が含まれます:

```Python
{
    "old key": "old value",
    "second old key": "second old value",
    "new key": "new value",
}
```