/*
   * The following methods are safe to call as long as both of the following hold:
   *
   * - allocArrays() has been called. Callers can confirm this by checking needsAllocArrays().
   *
   * - The map has not switched to delegating to a java.util implementation to mitigate hash
   *   flooding. Callers can confirm this by null-checking delegateOrNull().
   *

			var deleteMarkers uint64

			for i, nerr := range errs {
				if nerr != nil {
					continue
				}
				for _, fi := range versions[i].Versions {
					if fi.Deleted {
						// Delete markers are a write operation not a permanent delete.
						deleteMarkers++
						continue
					}
					permanentDeletes++
				}
			}
			if deleteMarkers > 0 {

	ListObjectVersions(ctx context.Context, bucket, prefix, marker, versionMarker, delimiter string, maxKeys int) (result ListObjectVersionsInfo, err error)
	// Walk lists all objects including versions, delete markers.
	Walk(ctx context.Context, bucket, prefix string, results chan<- itemOrErr[ObjectInfo], opts WalkOptions) error

	// Object operations.

	// GetObjectNInfo returns a GetObjectReader that satisfies the

    @Override
    public List<Long> subList(int fromIndex, int toIndex) {
      return parent.subArray(fromIndex, toIndex).asList();
    }

    /*
     * This is an override that is not directly visible to callers, so NewApi will catch calls to
     * Collection.spliterator() where necessary.
     */
    @IgnoreJRERequirement
    @Override
    public Spliterator.OfLong spliterator() {
      return parent.spliterator();

// It may return the (non-nil) error from the same call or return the error (and n == 0) from a subsequent call.
// Callers should always process the n > 0 bytes returned before considering the error err.
// Doing so correctly handles I/O errors that happen after reading some bytes and also both of the allowed EOF behaviors.

    }
  }

  /*
   * For a discussion of the signature of verifyNotNull, see the discussion above
   * Preconditions.checkNotNull.
   *
   * (verifyNotNull has many fewer "problem" callers, so we could try to be stricter. On the other
   * hand, verifyNotNull arguably has more reason to accept nullable arguments in the first
   * place....)
   */

  /**

## Version 5.1.0

_2025-07-07_

 *  New: `Response.peekTrailers()`. When we changed `Response.trailers()` to block instead of
    throwing in 5.0.0, we inadvertently removed the ability for callers to peek the trailers
    (by catching the `IllegalStateException` if they weren't available). This new API restores that
    capability.

    public static final String UNSAFE_URL = "unsafe-url";
  }

  /**
   * The HTTP <a href="https://www.w3.org/TR/service-workers/#update-algorithm">{@code
   * Service-Worker}</a> header field name.
   *
   * @since 20.0
   */
  public static final String SERVICE_WORKER = "Service-Worker";

  /** The HTTP {@code TE} header field name. */

		// Test listing an object with uncommon delimiter and matching prefix
		{testBuckets[4], "file1/", "", "guidSplunk", 1000, resultCases[35], nil, true},
		// Test listing at prefix with expected prefix markers
		{testBuckets[5], "dir/", "", SlashSeparator, 1, resultCases[36], nil, true},
		// Test listing with prefix match
		{testBuckets[5], "foo/201910/11", "", "", 1000, resultCases[37], nil, true},

  @Test
  fun networkInterceptorThrowsRuntimeExceptionSynchronous() {
    interceptorThrowsRuntimeExceptionSynchronous(true)
  }

  /**
   * When an interceptor throws an unexpected exception, synchronous callers can catch it and deal
   * with it.
   */
  private fun interceptorThrowsRuntimeExceptionSynchronous(network: Boolean) {
    addInterceptor(network) { chain: Interceptor.Chain? -> throw RuntimeException("boom!") }