t.Run(testCase.expectedOutput, func(t *testing.T) {
			gotOutput := ISO8601Format(testCase.date)
			t.Log("Go", testCase.date.Format(iso8601TimeFormat))
			if gotOutput != testCase.expectedOutput {
				t.Errorf("Expected %s, got %s", testCase.expectedOutput, gotOutput)
			}
		})
	}

        for (int i = 0; i < bytes / 8; i++) {
            tmp.writeLong(i);
        }
        bytesArray = tmp.copyBytes();
        if (bytesArray instanceof BytesArray == false) {
            throw new AssertionError("expected BytesArray but saw [" + bytesArray.getClass() + "]");
        }
        streamInput = bytesArray.streamInput();
    }

    @Benchmark
    public long readLong() throws IOException {
        long res = 0L;

        for (int i = 0; i < bytes / 8; i++) {
            tmp.writeLong(i);
        }
        pagedBytes = tmp.bytes();
        if (pagedBytes instanceof PagedBytesReference == false) {
            throw new AssertionError("expected PagedBytesReference but saw [" + pagedBytes.getClass() + "]");
        }
        this.streamInput = pagedBytes.streamInput();
    }

    @Benchmark
    public long readLong() throws IOException {

public class CollectionStreamTester<E> extends AbstractCollectionTester<E> {
  /*
   * We're not really testing the implementation of Stream, only that we're getting a Stream
   * that corresponds to the expected elements.
   */

  @CollectionFeature.Require(absent = KNOWN_ORDER)
  public void testStreamToArrayUnknownOrder() {
    Helpers.assertEqualIgnoringOrder(getSampleElements(), asList(collection.stream().toArray()));
  }

            .isEqualTo(expectation);
      }

      if (!expectedValues.containsKey(UNNECESSARY)) {
        assertWithMessage("Expected roundUnnecessaryShouldThrow call")
            .that(unnecessaryShouldThrow)
            .isTrue();
        assertThrows(
            "Expected ArithmeticException for roundToDouble(" + input + ", UNNECESSARY)",
            ArithmeticException.class,

 * specified the JVM flag {@code -XX:+DisableExplicitGC}. But in practice, it works very well for
 * ordinary tests.
 *
 * <p>Failure of the expected event to occur within an implementation-defined "reasonable" time
 * period or an interrupt while waiting for the expected event will result in a {@link
 * RuntimeException}.
 *
 * <p>Here's an example that tests a {@code finalize} method:
 *
 * {@snippet :

        new ActivationOS().equals(new ActivationOS());
    }

    @Test
    void testEqualsIdentity() {
        ActivationOS thing = new ActivationOS();
        assertTrue(thing.equals(thing), "Expected " + thing + " to equal " + thing);
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new ActivationOS().toString());
    }

        new PluginConfiguration().equals(new PluginConfiguration());
    }

    @Test
    void testEqualsIdentity() {
        PluginConfiguration thing = new PluginConfiguration();
        assertTrue(thing.equals(thing), "Expected " + thing + " to equal " + thing);
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new PluginConfiguration().toString());
    }

        new ReportPlugin().equals(new ReportPlugin());
    }

    @Test
    void testEqualsIdentity() {
        ReportPlugin thing = new ReportPlugin();
        assertTrue(thing.equals(thing), "Expected " + thing + " to equal " + thing);
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new ReportPlugin().toString());
    }

        new Reporting().equals(new Reporting());
    }

    @Test
    void testEqualsIdentity() {
        Reporting thing = new Reporting();
        assertTrue(thing.equals(thing), "Expected " + thing + " to equal " + thing);
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new Reporting().toString());
    }