}
    }

    /**
     * Associates {@code key} with {@code value} in the built map. If the same key is put more than
     * once, {@link #buildOrThrow} will fail, while {@link #buildKeepingLast} will keep the last
     * value put for that key.
     */
    @CanIgnoreReturnValue
    public Builder<K, V> put(K key, V value) {
      ensureCapacity(size + 1);
      checkEntryNotNull(key, value);

## we do not need to fail here, since we are going to test
## upgrading to master, healing and being able to recover
## the last version.
if [ $failed_count_site1 -ne 0 ]; then
	echo "failed with multipart on site1 uploads ${failed_count_site1}"
fi

if [ $failed_count_site2 -ne 0 ]; then

        // When/Then: Should throw UnknownHostException
        assertThrows(UnknownHostException.class, () -> pool.getSmbTransport(ctx, "unknown.host", 445, false, false));
    }

    @Test
    @DisplayName("Should throw last IOException when all connections fail")
    void testAllConnectionsFail() throws Exception {
        // Given: Multiple addresses that all fail
        Address addr1 = mock(Address.class);

     *
     * @param config the configuration to use
     * @param sid the search ID from a previous FindFirst2 response
     * @param resumeKey the resume key for continuing the search
     * @param filename the last filename from the previous response
     * @param batchCount the number of entries to return
     * @param batchSize the maximum size of the response buffer
     */

import okhttp3.TrailersSource
import okhttp3.internal.UnreadableResponseBody
import okhttp3.internal.http2.ConnectionShutdownException
import okhttp3.internal.skipAll
import okio.buffer

/** This is the last interceptor in the chain. It makes a network call to the server. */
object CallServerInterceptor : Interceptor {
  @Throws(IOException::class)
  override fun intercept(chain: Interceptor.Chain): Response {

 * views are modifiable.
 *
 * <p>This class is not threadsafe when any concurrent operations update the multimap. Concurrent
 * read operations will work correctly if the last write <i>happens-before</i> any reads. To allow
 * concurrent update operations, wrap your multimap with a call to {@link
 * Multimaps#synchronizedSetMultimap}.
 *

            assertEquals(filenameBytes[i], dst[6 + i], "Filename byte at index " + i + " should match.");
        }
        // Check null terminator
        assertEquals((byte) 0x00, dst[dst.length - 1], "The last byte should be a null terminator.");
    }

    /**
     * Tests the writeDataWireFormat method.
     */
    @Test
    void testWriteDataWireFormat() {
        // Given

        // what we wanted: a new file that probably has its last modified time set to approximately
        // now. Or it could have an arbitrary last modified time set by the creator, but that's no
        // different than if another process set its last modified time to something else after we
        // created it here.
      }
    }
  }

  /**

  private val enforceOrder: Boolean = true,
) : ConnectionListener() {
  val eventSequence: Deque<ConnectionEvent> = ConcurrentLinkedDeque()

  private val forbiddenLocks = mutableSetOf<Any>()

  /** The timestamp of the last taken event, used to measure elapsed time between events. */
  private var lastTimestampNs: Long? = null

  /** Confirm that the thread does not hold a lock on `lock` during the callback. */
  fun forbidLock(lock: Any) {

    }

    @Override
    @ParametricNullness
    public E first() {
      return getElementOrThrow(multiset().firstEntry());
    }

    @Override
    @ParametricNullness
    public E last() {
      return getElementOrThrow(multiset().lastEntry());
    }
  }

  /** A skeleton navigable implementation for {@link SortedMultiset#elementSet}. */
  @GwtIncompatible // Navigable