@CollectionFeature.Require(KNOWN_ORDER)
  public void testForEachKnownOrder() {
    List<E> elements = new ArrayList<>();
    collection.forEach(elements::add);
    List<E> expected = Helpers.copyToList(getOrderedElements());
    assertEquals("Different ordered iteration", expected, elements);
  }

    assertArrayEquals("toArray(largeEnough) order should match list", createOrderedArray(), actual);
  }

  private static void assertArrayEquals(String message, Object[] expected, Object[] actual) {
    assertEquals(message, asList(expected), asList(actual));
  }

    try (Response response = call.execute()) {
      System.out.printf("%.2f Call was expected to fail, but completed: %s%n",
          (System.nanoTime() - startNanos) / 1e9f, response);
    } catch (IOException e) {
      System.out.printf("%.2f Call failed as expected: %s%n",
          (System.nanoTime() - startNanos) / 1e9f, e);
    }
  }

        assertFalse(r1.hashCode() == r3.hashCode());

        assertTrue(r1.equals(r2), "Expected " + r1 + " to equal " + r2);
        assertTrue(r2.equals(r1), "Expected " + r2 + " to equal " + r1);

        assertFalse(r1.equals(r3), "Expected " + r1 + " to not equal " + r3);
        assertFalse(r3.equals(r1), "Expected " + r3 + " to not equal " + r1);
    }

	tok := in.Stack.Next()
	if tok != scanner.Int {
		in.expectText("expected line number after #line")
	}
	line, err := strconv.Atoi(in.Stack.Text())
	if err != nil {
		in.Error("error parsing #line (cannot happen):", err)
	}
	tok = in.Stack.Next()
	if tok != scanner.String {
		in.expectText("expected file name in #line")
	}
	file, err := strconv.Unquote(in.Stack.Text())
	if err != nil {

	credentials auth.Credentials, t *testing.T,
) {
	// test cases with sample input and expected output.
	testCases := []struct {
		method     string
		bucketName string
		accessKey  string
		secretKey  string
		// Sent body
		body []byte
		// Expected response
		expectedRespStatus int
		lifecycleResponse  []byte
		errorResponse      APIErrorResponse
		shouldPass         bool
	}{

      }
      assertEquivalent(expectedResult, collector.finisher().apply(finalAccum));
    }
  }

  private void assertEquivalent(R expected, R actual) {
    assertTrue(
        "Expected " + expected + " got " + actual + " modulo equivalence " + equivalence,
        equivalence.test(expected, actual));
  }

        assertTrue(f1.equals(f2), "Expected " + f1 + " to equal " + f2);
        assertTrue(f2.equals(f1), "Expected " + f2 + " to equal " + f1);
        assertTrue(f1.hashCode() == f2.hashCode());

        IncludesArtifactFilter f3 = new IncludesArtifactFilter(Arrays.asList("d", "c", "e"));
        assertTrue(f1.equals(f3), "Expected " + f1 + " to equal " + f3);
        assertTrue(f1.hashCode() == f3.hashCode());

}

var removeInternalEntriesTests = []struct {
	Metadata, Expected map[string]string
}{
	{ // 0
		Metadata: map[string]string{
			MetaMultipart:         "",
			MetaIV:                "",
			MetaAlgorithm:         "",
			MetaSealedKeySSEC:     "",
			MetaSealedKeyS3:       "",
			MetaKeyID:             "",
			MetaDataEncryptionKey: "",
		},
		Expected: map[string]string{},
	},
	{ // 1

  }

  /**
   * Verify that the listener completes in a reasonable amount of time, and Asserts that the future
   * 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 {