@CanIgnoreReturnValue
  public final <A extends Appendable> A appendTo(
      A appendable, @Nullable Object first, @Nullable Object second, @Nullable Object... rest)
      throws IOException {
    return appendTo(appendable, iterable(first, second, rest));
  }

  /**
   * Appends the string representation of each of {@code parts}, using the previously configured

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

Here, `new_dict` will contain all the key-value pairs from `old_dict` plus the new key-value pair:

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

      implements Serializable {
    final Converter<A, B> first;
    final Converter<B, C> second;

    ConverterComposition(Converter<A, B> first, Converter<B, C> second) {
      this.first = first;
      this.second = second;
    }

    /*
     * These gymnastics are a little confusing. Basically this class has neither legacy nor

    }

    @Test
    @DisplayName("Iterator with rejecting filter - finds next acceptable")
    void iteratorWithRejectingFilter() throws Exception {
        // Setup: first entry rejected, second accepted
        FileEntry entry1 = mock(FileEntry.class);
        FileEntry entry2 = mock(FileEntry.class);

        when(delegate.hasNext()).thenReturn(true, true, false);

        int result = smbComRename.writeBytesWireFormat(dst, dstIndex);

        // Then
        assertTrue(result > 0);
        assertEquals((byte) 0x04, dst[0]); // First buffer format byte

        // Find the second buffer format byte
        int secondBufferFormatIndex = oldFileName.length() + 2; // 1 for first 0x04, 1 for null terminator
        assertEquals((byte) 0x04, dst[secondBufferFormatIndex]);
    }

    /**

        assertThrows(IllegalStateException.class, () -> {
            Handler.setURLStreamHandlerFactory(mockFactory2); // Second call, should fail.
        }, "Setting the factory a second time should throw IllegalStateException.");
    }

    @Test
    void testOpenConnection_WithCustomFactory() throws Exception {

    /**
     * Cache for exclude filters.
     */
    protected LoadingCache<String, List<Pattern>> excludeFilterCache;

    /**
     * The expiration time for the filter cache in seconds.
     */
    protected int filterCacheExpireAfterWrite = 10; // 10sec

    /**
     * The maximum number of items to load into the cache.
     */
    protected int maxLoadSize = 10000;

    /**

package cmd

import (
	"context"
	"time"
)

var sharedLockTimeout = newDynamicTimeoutWithOpts(dynamicTimeoutOpts{
	timeout:       30 * time.Second,
	minimum:       10 * time.Second,
	retryInterval: time.Minute,
})

type sharedLock struct {
	lockContext chan LockContext
}

func (ld sharedLock) backgroundRoutine(ctx context.Context, objAPI ObjectLayer, lockName string) {

@GwtCompatible
@NullMarked
public class AbstractIteratorTest extends TestCase {

  public void testDefaultBehaviorOfNextAndHasNext() {

    // This sample AbstractIterator returns 0 on the first call, 1 on the
    // second, then signals that it's reached the end of the data
    Iterator<Integer> iter =
        new AbstractIterator<Integer>() {
          private int rep;

          @Override
          public @Nullable Integer computeNext() {

import static com.google.common.base.StandardSystemProperty.JAVA_SPECIFICATION_VERSION;
import static com.google.common.truth.Truth.assertThat;
import static java.lang.Integer.parseInt;
import static java.util.concurrent.TimeUnit.SECONDS;

import java.lang.reflect.Method;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import junit.framework.TestCase;