MetaSsecCRC = "X-Minio-Replication-Ssec-Crc"

	// MetaContext is the KMS context provided by a client when encrypting an
	// object with SSE-KMS. A client may not send a context in which case the
	// MetaContext will not be present.
	// MetaContext only contains the bucket/object name if the client explicitly
	// added it. However, when decrypting an object the bucket/object name must

        return false;
    }

    @FunctionalInterface
    protected interface ChildrenTracking {
        boolean replace(Object oldDelegate, Object newDelegate);
    }

 *
 * @author Hayward Chan
 */
final class Platform {
  static <K extends @Nullable Object, V extends @Nullable Object>
      Map<K, V> newHashMapWithExpectedSize(int expectedSize) {
    return Maps.newHashMapWithExpectedSize(expectedSize);
  }

  static <K extends @Nullable Object, V extends @Nullable Object>
      Map<K, V> newLinkedHashMapWithExpectedSize(int expectedSize) {

  }

  public void testAwaitClear() {
    WeakReference<Object> ref = createWeakReference();
    GcFinalization.awaitClear(ref);
    assertThat(ref.get()).isNull();
  }

  private WeakReference<Object> createWeakReference() {
    return new WeakReference<>(new Object());
  }

  public void testAwaitDone_finalizationPredicate() {
    WeakHashMap<Object, Object> map = new WeakHashMap<>();

    private final Table<R, C, V> delegate = HashBasedTable.create();
    private final Object mutex = new Object[0]; // something Serializable

    @Override
    public String toString() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.toString();
    }

    @Override
    public boolean equals(@Nullable Object o) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.equals(o);
    }

    T proxy =
        Reflection.newProxy(
            interfaceType,
            new AbstractInvocationHandler() {
              @Override
              protected Object handleInvocation(Object p, Method m, @Nullable Object[] args)
                  throws Throwable {
                throw exception;
              }
            });
    T wrapper = wrapperFunction.apply(proxy);
    try {

    class Transformer implements Function<Object, Object> {
      @SuppressWarnings("nullness:initialization.field.uninitialized")
      ListenableFuture<Object> output;

      @Override
      public Object apply(Object input) {
        output.cancel(false);
        throw new SomeError();
      }
    }
    Transformer transformer = new Transformer();
    SettableFuture<Object> input = SettableFuture.create();

    class Transformer implements Function<Object, Object> {
      @SuppressWarnings("nullness:initialization.field.uninitialized")
      ListenableFuture<Object> output;

      @Override
      public Object apply(Object input) {
        output.cancel(false);
        throw new SomeError();
      }
    }
    Transformer transformer = new Transformer();
    SettableFuture<Object> input = SettableFuture.create();

  static class SuperClass {
    final List<Object> neitherOverriddenNorAnnotatedEvents = new ArrayList<>();
    final List<Object> overriddenInSubclassNowhereAnnotatedEvents = new ArrayList<>();
    final List<Object> overriddenAndAnnotatedInSubclassEvents = new ArrayList<>();

    public void neitherOverriddenNorAnnotated(Object o) {
      neitherOverriddenNorAnnotatedEvents.add(o);
    }

   */
  void moveLastEntry(int dstIndex, int mask) {
    Object table = requireTable();
    int[] entries = requireEntries();
    @Nullable Object[] elements = requireElements();
    int srcIndex = size() - 1;
    if (dstIndex < srcIndex) {
      // move last entry to deleted spot
      Object object = elements[srcIndex];
      elements[dstIndex] = object;
      elements[srcIndex] = null;