private static final byte[] VALUES = {Byte.MIN_VALUE, -1, 0, 1, Byte.MAX_VALUE};

  // We need to test that our method behaves like the JDK method.
  @SuppressWarnings("InlineMeInliner")
  public void testHashCode() {
    for (byte value : VALUES) {
      assertThat(Bytes.hashCode(value)).isEqualTo(Byte.hashCode(value));
    }
  }

  public void testContains() {

    assertThat(copy.cellSet()).containsExactlyElementsIn(original.cellSet()).inOrder();
    assertThat(copy.rowKeySet()).containsExactlyElementsIn(original.rowKeySet()).inOrder();
    assertThat(copy.values()).containsExactlyElementsIn(original.values()).inOrder();
  }

  public void testCopyOf() {
    Table<Character, Integer, String> table = TreeBasedTable.create();
    validateTableCopies(table);
    table.put('b', 2, "foo");

                                    ? null
                                    : model.getDependencyManagement().withDependencies(managedDependencies.values()))
                    .withDependencies(directDependencies.isEmpty() ? null : directDependencies.values());
        } else {
            // Even without dependencyManagement, filter direct dependencies to compile/runtime only

    @NullAndEmptySource
    @ValueSource(strings = { "", "share1", "\\\\server\\share", "C$", "ADMIN$", "IPC$" })
    void testConstructorWithDifferentSharenames(String sharename) {
        // Test with various sharename values
        MsrpcShareGetInfo shareGetInfo = new MsrpcShareGetInfo(testServer, sharename);
        assertNotNull(shareGetInfo);
        assertEquals(sharename, shareGetInfo.sharename);

    cache.put(20, 22);
    cache.put(5, 10);

    fakeTicker.advance(501, MILLISECONDS);

    assertThat(cache.asMap().values().contains(22)).isTrue();
    assertThat(cache.asMap().values().contains(10)).isTrue();
    assertThat(cache.asMap().values().contains(20)).isFalse();
  }

  @Test
  @J2ktIncompatible
  public void asMapKeySet() {
    Cache<Integer, Integer> cache =

            final VaErrorHook hook) {
        if (values.length == 0) {
            return;
        }
        for (final String value : values) {
            if (value.indexOf(',') >= 0) {
                action.throwValidationError(messages -> {
                    messages.addErrorsInvalidStrIsIncluded(propertyName, value, ",");
                }, hook);

          array[i] = counter.getAndIncrement();
        }
        builder.addAll(array);
      }
    },
    ;

    static final BuilderOp[] values = values();

    static BuilderOp randomOp() {
      return values[random.nextInt(values.length)];
    }

    abstract void doIt(ImmutableIntArray.Builder builder, AtomicInteger counter);
  }

  private static final Random random = new Random(42);

# Currently, there is no way to pass multiple cookies with the same name.
# The only way to pass multiple values for cookie params is to serialize them using

    builder.put("key", "value");
    assertThat(builder.build().entries()).containsExactly(Maps.immutableEntry("key", "value"));
  }

  public void testBuilderWithExpectedKeysPositive() {
    ImmutableListMultimap.Builder<String, String> builder =
        ImmutableListMultimap.builderWithExpectedKeys(1);
    builder.put("key", "value");

    assertThat(Floats.indexOf(new float[] {4.0f, 3.0f, 2.0f}, new float[] {2.0f, 3.0f, 4.0f}))
        .isEqualTo(-1);

    for (float value : NUMBERS) {
      assertWithMessage("%s", value)
          .that(Floats.indexOf(new float[] {5f, value, value, 5f}, new float[] {value, value}))
          .isEqualTo(1);
    }
    assertThat(Floats.indexOf(new float[] {5f, NaN, NaN, 5f}, new float[] {NaN, NaN}))
        .isEqualTo(-1);