@Override
    public boolean contains(@Nullable Object target) {
      // Overridden to prevent a ton of boxing
      return (target instanceof Boolean)
          && Booleans.indexOf(array, (Boolean) target, start, end) != -1;
    }

    @Override
    public int indexOf(@Nullable Object target) {
      // Overridden to prevent a ton of boxing
      if (target instanceof Boolean) {

    }

    /** Adds a key-value mapping to the built multimap if it is not already present. */
    @CanIgnoreReturnValue
    @Override
    public Builder<K, V> put(K key, V value) {
      super.put(key, value);
      return this;
    }

    /**
     * Adds an entry to the built multimap if it is not already present.
     *
     * @since 11.0
     */
    @CanIgnoreReturnValue
    @Override

        assertTrue(parsed.getContextFlag(NegTokenInit.INTEGRITY));
        assertFalse(parsed.getContextFlag(NegTokenInit.CONFIDENTIALITY));
    }

    @Test
    @DisplayName("Minimal token: no fields present")
    void testMinimalTokenRoundTrip() throws Exception {
        NegTokenInit init = new NegTokenInit(); // no fields
        byte[] bytes = init.toByteArray();

        NegTokenInit parsed = new NegTokenInit(bytes);

        CipherSuite.TLS_RSA_WITH_AES_256_CBC_SHA,
        CipherSuite.TLS_RSA_WITH_3DES_EDE_CBC_SHA,
      )

    /** A secure TLS connection that requires a recent client platform and a recent server. */
    @JvmField
    val RESTRICTED_TLS =
      Builder(true)
        .cipherSuites(*RESTRICTED_CIPHER_SUITES.toTypedArray())
        .tlsVersions(TlsVersion.TLS_1_3, TlsVersion.TLS_1_2)

   *
   * @param collection the collection whose complement should be stored in the enum set
   * @return a new, modifiable {@code EnumSet} containing all values of the enum that aren't present
   *     in the given collection
   * @throws IllegalArgumentException if {@code collection} is not an {@code EnumSet} instance and
   *     contains no elements
   */
  @J2ktIncompatible

type metaCacheEntry struct {
	// name is the full name of the object including prefixes
	name string
	// Metadata. If none is present it is not an object but only a prefix.
	// Entries without metadata will only be present in non-recursive scans.
	metadata []byte

	// cached contains the metadata if decoded.
	cached *xlMetaV2

func (o *MultipartInfo) KMSKeyID() string { return kmsKeyIDFromMetadata(o.UserDefined) }

// kmsKeyIDFromMetadata returns any AWS S3 KMS key ID in the
// metadata, if any. It returns an empty ID if no key ID is
// present.
func kmsKeyIDFromMetadata(metadata map[string]string) string {
	const ARNPrefix = crypto.ARNPrefix
	if len(metadata) == 0 {
		return ""
	}
	kmsID, ok := metadata[crypto.MetaKeyID]
	if !ok {
		return ""
	}

			t.Fatalf("Object %s is not removed", test.bucket+SlashSeparator+test.object)
		}
	}

	if _, err = os.ReadFile(pathJoin(fsDirs[0], bucketName, "dir/obj1", "xl.meta")); err == nil {
		t.Fatalf("xl.meta still present after removal")
	}
}

func TestErasureDeleteObjectsErasureSet(t *testing.T) {
	ctx, cancel := context.WithCancel(t.Context())
	defer cancel()

	obj, fsDirs, err := prepareErasureSets32(ctx)

// in 'pool.bin', this is eventually used for decommissioning the pool.
func (z *erasureServerPools) Init(ctx context.Context) error {
	// Load rebalance metadata if present
	if err := z.loadRebalanceMeta(ctx); err == nil {
		// Start rebalance routine if we can reload rebalance metadata.
		z.StartRebalance()
	}

	meta := poolMeta{}

        } catch (Exception e) {
            // It's ok if it fails, we just want to verify reset was called
        }

        // Request/response reset should happen on retry
        verify(req, atLeastOnce()).reset();
        verify(resp, atLeastOnce()).reset();
        // Verify disconnect was called on retry
        verify(c, atLeastOnce()).disconnect(eq(true));
    }

    @Test