static boolean equal(@Nullable Object a, @Nullable Object b) {
    return a == b || (a != null && a.equals(b));
  }

  // Clone of Lists.newArrayList
  public static <E extends @Nullable Object> List<E> copyToList(Iterable<? extends E> elements) {
    List<E> list = new ArrayList<>();
    addAll(list, elements);
    return list;
  }

  public static <E extends @Nullable Object> List<E> copyToList(E[] elements) {

    } catch (AssertionError expected) {
      return;
    }
    fail();
  }

  public static final class BadSerializableFactory {
    public static Object bad() {
      return new Serializable() {
        @Keep private final Object notSerializable = new Object();
      };
    }

    private BadSerializableFactory() {}
  }

  public void testEqualsAndSerializableOnReturnValues_equalsIsGoodButNotSerializable()

      purge:
          # retainVersions: 0 # (default) delete all versions of the object. This option is the fastest.
          # retainVersions: 5 # keep the latest 5 versions of the object.
  
    - type: deleted # objects with delete marker as their latest version
      name: NAME # match object names that satisfy the wildcard expression.
      olderThan: 10h # match objects older than this value (e.g. 7d10h31s)

    @Subscribe
    public void handle(@Nullable Object unused) {}

    Subscriber toSubscriber() throws Exception {
      return Subscriber.create(eventBus, this, subscriberMethod());
    }

    SubscriberExceptionContext toContext() {
      return new SubscriberExceptionContext(eventBus, new Object(), this, subscriberMethod());
    }

    private static Method subscriberMethod() {

	z := obj.(*erasureServerPools)
	xl := z.serverPools[0].sets[0]

	bucket := "test-bucket"
	object := "test-object"

	err = obj.MakeBucket(ctx, bucket, MakeBucketOptions{})
	if err != nil {
		t.Fatal(err)
	}

	// Put an initial object so it exists
	_, err = obj.PutObject(ctx, bucket, object,
		mustGetPutObjReader(t, bytes.NewReader([]byte("initial-value")),
			int64(len("initial-value")), "", ""), ObjectOptions{})

      }
    }
  }

  private static final Object PRED = new Object();

  // Every value in this map must either be an instance of PredAndSucc with a successorValue of
  // type V, PRED (representing predecessor), or an instance of type V (representing successor).
  private final Map<N, Object> adjacentNodeValues;

  /**
   * All node connections in this graph, in edge insertion order.

    //                                                                              ======
    @Override
    public Map<String, Object> toSource() {
        Map<String, Object> sourceMap = new HashMap<>();
        if (boostExpr != null) {
            addFieldToSource(sourceMap, "boostExpr", boostExpr);
        }
        if (createdBy != null) {

        if (options != null) {
            final Iterator iter = options.keySet().iterator();
            while (iter.hasNext()) {
                final Object key = iter.next();
                final Object val = options.get(key);
                ret.append(",").append(key).append("=").append(val);
            }
        }
        ret.append("]");
        return ret.toString();
    }

    Object computed = new Object();
    LoadingCache<Object, Object> cache =
        CacheBuilder.newBuilder()
            .expireAfterWrite(0, SECONDS)
            .removalListener(listener)
            .build(constantLoader(computed));

    Object key = new Object();
    assertThat(cache.getUnchecked(key)).isSameInstanceAs(computed);
    RemovalNotification<Object, Object> notification = listener.remove();

    Object computed = new Object();
    LoadingCache<Object, Object> cache =
        CacheBuilder.newBuilder()
            .expireAfterWrite(0, SECONDS)
            .removalListener(listener)
            .build(constantLoader(computed));

    Object key = new Object();
    assertThat(cache.getUnchecked(key)).isSameInstanceAs(computed);
    RemovalNotification<Object, Object> notification = listener.remove();