this.expectInfoType = expectInfoType;
        this.expectInfoClass = expectInfoClass;
    }

    /**
     * Gets the information returned by the query
     *
     * @return the information
     */
    public Decodable getInfo() {
        return this.info;
    }

    /**
     * Gets the information returned by the query, cast to the specified class type
     *
     * @param <T>

				t.Fatalf("Failed to putObject %v", err)
			}

			partsMetadata, errs := readAllFileInfo(ctx, erasureDisks, "", bucket, object, "", false, true)
			fi, err := getLatestFileInfo(ctx, partsMetadata, z.serverPools[0].sets[0].defaultParityCount, errs)
			if err != nil {
				t.Fatalf("Failed to getLatestFileInfo %v", err)
			}

			for j := range partsMetadata {
				if errs[j] != nil {

    supported on Android, Java, or Conscrypt.

    We removed this cipher suite and `TLS_AES_128_CCM_SHA256` from the restricted, modern, and
    compatible sets of cipher suites. These two cipher suites aren't enabled by default in either
    Firefox or Chrome.

    See our [TLS Configuration History][tls_configuration_history] tracker for a log of all changes

    }

    // ========== Thread Safety Tests ==========

    /**
     * Test that the volatile alive field is visible across threads.
     * One thread sets alive to false, other threads should see the change immediately.
     */
    @Test
    public void test_aliveField_volatileVisibility() throws Exception {
        // Ensure alive starts as true

package com.google.common.collect.testing;

import com.google.common.annotations.GwtCompatible;
import java.util.List;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Creates sets, containing sample elements, to be tested.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
@NullMarked
public interface TestListGenerator<E extends @Nullable Object> extends TestCollectionGenerator<E> {
  @Override

    }

    @Override
    Set<E> createElementSet() {
      return Sets.filter(unfiltered.elementSet(), predicate);
    }

    @Override
    Iterator<E> elementIterator() {
      throw new AssertionError("should never be called");
    }

    @Override
    Set<Entry<E>> createEntrySet() {
      return Sets.filter(unfiltered.entrySet(), entry -> predicate.apply(entry.getElement()));
    }

    }

    @Override
    Set<E> createElementSet() {
      return Sets.filter(unfiltered.elementSet(), predicate);
    }

    @Override
    Iterator<E> elementIterator() {
      throw new AssertionError("should never be called");
    }

    @Override
    Set<Entry<E>> createEntrySet() {
      return Sets.filter(unfiltered.entrySet(), entry -> predicate.apply(entry.getElement()));
    }

  }

  /** Returns the platform preferred implementation of a set based on a hash table. */
  static <E extends @Nullable Object> Set<E> newHashSetWithExpectedSize(int expectedSize) {
    return Sets.newHashSetWithExpectedSize(expectedSize);
  }

  /** Returns the platform preferred implementation of a thread-safe hash set. */
  static <E> Set<E> newConcurrentHashSet() {
    return ConcurrentHashMap.newKeySet();
  }

func NewEvaluator(policy Lifecycle) *Evaluator {
	return &Evaluator{
		policy: policy,
	}
}

// WithLockRetention - sets the lock retention configuration for the evaluator
func (e *Evaluator) WithLockRetention(lr *objlock.Retention) *Evaluator {
	e.lockRetention = lr
	return e
}

// WithReplicationConfig - sets the replication configuration for the evaluator
func (e *Evaluator) WithReplicationConfig(rcfg *replication.Config) *Evaluator {

func (r *ReqInfo) AppendTags(key, val string) *ReqInfo {
	if r == nil {
		return nil
	}
	r.Lock()
	defer r.Unlock()
	r.tags = append(r.tags, KeyVal{key, val})
	return r
}

// SetTags - sets key/val to ReqInfo.tags
func (r *ReqInfo) SetTags(key, val string) *ReqInfo {
	if r == nil {
		return nil
	}
	r.Lock()
	defer r.Unlock()
	// Search of tag key already exists in tags
	var updated bool