public void testFromInt() {
    for (ExpectedHashCode expected : expectedHashCodes) {
      if (expected.bytes.length == 4) {
        HashCode fromInt = HashCode.fromInt(expected.asInt);
        assertExpectedHashCode(expected, fromInt);
      }
    }
  }

  // expectedHashCodes must contain at least one hash code with 8 bytes
  public void testFromLong() {
    for (ExpectedHashCode expected : expectedHashCodes) {

			if err != nil {
				t.Fatalf("error: expected: %v, got: %v", testCase.expectedErr, err)
			}
		case err == nil:
			t.Fatalf("error: expected: %v, got: %v", testCase.expectedErr, err)
		case testCase.expectedErr.Error() != err.Error():
			t.Fatalf("error: expected: %v, got: %v", testCase.expectedErr, err)
		}

		if testCase.expectedResult != result {
			t.Fatalf("result: expected: %v, got: %v", testCase.expectedResult, result)

  }

  public void testOnlyElementMultiple() {
    IllegalArgumentException expected =
        assertThrows(IllegalArgumentException.class, () -> Stream.of(1, 2).collect(onlyElement()));
    assertThat(expected.getMessage()).contains("1, 2");
  }

  public void testOnlyElementMany() {
    IllegalArgumentException expected =
        assertThrows(
            IllegalArgumentException.class,

			err := listTags(context.Background(), client, &out)
			if tc.error == "" && err != nil {
				t.Fatalf("expected no error, got %v", err)
			}
			if tc.error != "" {
				if err == nil {
					t.Fatalf("expected error to include \"%s\" but got none", tc.error)
				}
				if !strings.Contains(err.Error(), tc.error) {
					t.Fatalf("expected \"%s\" in error, got %v", tc.error, err)
				}
			}

			commandOutput := out.String()

      sink.flush()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("stream finished")
    }
    assertFailsWith<IOException> {
      stream.getSource().read(Buffer(), 1)
    }.also { expected ->
      assertThat(expected.message).isEqualTo("stream was reset: CANCEL")
    }

    // Verify the peer received what was expected.
    val synStream = peer.takeFrame()

    int i = 0;
    while (expectedIterator.hasNext()) {
      Object expected = expectedIterator.next();

      assertTrue(
          "index " + i + " expected <" + expected + "., actual is exhausted",
          actualIterator.hasNext());

      Object actual = actualIterator.next();
      assertEquals("index " + i, expected, actual);
      i++;
    }
    if (actualIterator.hasNext()) {

    for (long value : TEST_LONGS) {
      BigInteger expected =
          (value >= 0)
              ? BigInteger.valueOf(value)
              : BigInteger.valueOf(value).add(BigInteger.ZERO.setBit(64));
      assertWithMessage(UnsignedLongs.toString(value))
          .that(UnsignedLong.fromLongBits(value).bigIntegerValue())
          .isEqualTo(expected);
    }
  }

  public void testValueOfLong() {

    }

    try {
      assertContentsInOrder(list, "a", "c", "b");
      throw new Error();
    } catch (AssertionFailedError expected) {
    }

    try {
      assertContentsInOrder(list, "a", "B", "c");
      throw new Error();
    } catch (AssertionFailedError expected) {
    }
  }

  public void testAssertContains() {
    List<?> list = asList("a", "b");

    }

    try {
      assertContentsInOrder(list, "a", "c", "b");
      throw new Error();
    } catch (AssertionFailedError expected) {
    }

    try {
      assertContentsInOrder(list, "a", "B", "c");
      throw new Error();
    } catch (AssertionFailedError expected) {
    }
  }

  public void testAssertContains() {
    List<?> list = asList("a", "b");

  public void testEquals() {
    resetContainer(mapEntry(k0(), v0()), mapEntry(k1(), v0()), mapEntry(k0(), v3()));
    Map<K, Collection<V>> expected = Maps.newHashMap();
    expected.put(k0(), newHashSet(v0(), v3()));
    expected.put(k1(), newHashSet(v0()));
    new EqualsTester().addEqualityGroup(expected, multimap().asMap()).testEquals();
  }

  @CollectionSize.Require(SEVERAL)
  public void testEntrySetEquals() {