}

    @Override
    public int hashCode() {
        int hash = 17;
        hash = hash * 31 + filters.hashCode();
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

        if (obj instanceof OrArtifactFilter other) {
            return filters.equals(other.filters);
        } else {

        Thread.currentThread().interrupt();
        break;
      default:
        throw new AssertionError("unsupported scenario: " + scenario);
    }
  }

  private Outcome doCall() {
    List<Object> arguments = new ArrayList<>();
    if (isGuarded(method)) {
      arguments.add(guard);
    }
    if (isLongTimeUnitBased(method)) {
      arguments.add(timeout.millis);
      arguments.add(TimeUnit.MILLISECONDS);

    ImmutableList.Builder<Integer> builder = ImmutableList.builderWithExpectedSize(10);
    Object[] builderArray = builder.contents;
    for (int i = 0; i < 10; i++) {
      builder.add(i);
    }
    Object[] builderArrayAfterAdds = builder.contents;
    RegularImmutableList<Integer> list = (RegularImmutableList<Integer>) builder.build();
    Object[] listInternalArray = list.array;
    assertSame(builderArray, builderArrayAfterAdds);

      this.gen = gen;
    }

    @Override
    public SampleElements<E> samples() {
      return gen.samples();
    }

    @Override
    public Collection<E> create(Object... elements) {
      return SerializableTester.reserialize(gen.create(elements));
    }

    @Override
    public E[] createArray(int length) {
      return gen.createArray(length);
    }

    @Override

  @CollectionSize.Require(absent = ZERO)
  public void testCreateWithNull_unsupported() {
    E[] array = createArrayWithNullElement();

    assertThrows(
        NullPointerException.class,
        () -> {
          Object unused = getSubjectGenerator().create(array);
        });
  }

  /**
   * Returns the {@link Method} instance for {@link #testCreateWithNull_unsupported()} so that tests

   * returns the expected data.
   *
   * @throws Throwable if the listener isn't called or if it resulted in a throwable or if the
   *     result doesn't match the expected value.
   */
  public void assertSuccess(Object expectedData) throws Throwable {
    // Verify that the listener executed in a reasonable amount of time.
    Assert.assertTrue(countDownLatch.await(1L, SECONDS));

    try {

    assertFalse(future.isDone());
    assertFalse(future.isCancelled());
  }

  public void tearDown() {
    exec.shutdown();
  }

  public void testCompletedFuture(@Nullable Object expectedValue)
      throws InterruptedException, ExecutionException {
    assertTrue(future.isDone());
    assertFalse(future.isCancelled());

    assertTrue(latch.await(5, SECONDS));
    assertTrue(future.isDone());

     * @param <T> the target type to unwrap to
     * @param type the class of the target type
     * @return the referral adapted to type
     * @throws ClassCastException
     *             if the type is not valid for this object
     */
    <T extends DfsReferralData> T unwrap(Class<T> type);

    /**
     * Get the server this referral points to
     *
     * @return the server this referral points to
     */
    String getServer();

    @Override
    public String toString() {
        return getLocation();
    }

    @Override
    public int hashCode() {
        return hashCode;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

        if (obj == null) {
            return false;
        }

        if (!StringSource.class.equals(obj.getClass())) {

# 2. Now access the server as user `foo`. These operations will also succeed.
export MC_HOST_foo=http://foo:foobar123@localhost:9000
mc ls foo/test
mc cat foo/test/issue

# 3. Attempt to upload an object as user `foo` - this will fail with a permissions error.
mc cp /etc/issue myminio/test/issue2