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

  @SuppressWarnings("InlineMeInliner") // We need to test our method.
  public void testIsFinite() {
    for (float value : NUMBERS) {

    RowSortedTable<Character, String, Integer> table = TreeBasedTable.create();
    table.put('a', "one", 1);
    table.put('a', "two", 2);
    table.put('a', "three", 3);
    table.put('b', "four", 4);
    return unmodifiableRowSortedTable(table).row('a');
  }

    assertMultimapEquals(
        ImmutableListMultimap.of("one", 1, "two", 2, "three", 3, "four", 4),
        "one",
        1,
        "two",
        2,
        "three",
        3,
        "four",
        4);
    assertMultimapEquals(
        ImmutableListMultimap.of("one", 1, "two", 2, "three", 3, "four", 4, "five", 5),
        "one",
        1,
        "two",
        2,
        "three",

    public String[] createValueArray(int length) {
      return new String[length];
    }

    @Override
    public SampleElements<String> sampleKeys() {
      return new SampleElements<>("one", "two", "three", "four", "five");
    }

    @Override
    public SampleElements<String> sampleValues() {
      return new SampleElements<>("january", "february", "march", "april", "may");
    }

    @Override

    return Ints.fromBytes((byte) 0, (byte) 0, b2, b1);
  }

  /**
   * Reads an integer as specified by {@link DataInputStream#readInt()}, except using little-endian
   * byte order.
   *
   * @return the next four bytes of the input stream, interpreted as an {@code int} in little-endian
   *     byte order
   * @throws IOException if an I/O error occurs
   */
  @CanIgnoreReturnValue // to skip some bytes
  @Override

    }

    @Test
    @DisplayName("Should join multiple elements with delimiter")
    void testJoinMultipleElements() {
        String result = StringUtil.join(",", "one", "two", "three", "four");
        assertEquals("one,two,three,four", result);
    }

    @Test
    @DisplayName("Should join with empty string delimiter")
    void testJoinWithEmptyDelimiter() {
        String result = StringUtil.join("", "hello", "world");

    String message = "Waited " + timeout + " " + unit.toString().toLowerCase(Locale.ROOT);
    // Only report scheduling delay if larger than our spin threshold - otherwise it's just noise
    if (remainingNanos + SPIN_THRESHOLD_NANOS < 0) {
      // We over-waited for our timeout.
      message += " (plus ";
      long overWaitNanos = -remainingNanos;
      long overWaitUnits = unit.convert(overWaitNanos, NANOSECONDS);

    assertMultimapEquals(
        ImmutableSetMultimap.of("one", 1, "two", 2, "three", 3, "four", 4),
        "one",
        1,
        "two",
        2,
        "three",
        3,
        "four",
        4);
    assertMultimapEquals(
        ImmutableSetMultimap.of("one", 1, "two", 2, "three", 3, "four", 4, "five", 5),
        "one",
        1,
        "two",
        2,
        "three",

        - Documentation Bug
        - Others
    validations:
      required: true
  - type: markdown
    attributes:
      value: |
        Please make sure that this is a bug. As per our [GitHub Policy](https://github.com/tensorflow/tensorflow/blob/master/ISSUES.md), we only address code/doc bugs, performance issues, feature requests and build/installation issues on GitHub.

  - type: dropdown
    id: tf-nightly

      if (delegate == null) {
        return;
      }

      /*
       * If we're about to complete the TimeoutFuture, we want to release our reference to it.
       * Otherwise, we'll pin it (and its result) in memory until the timeout task is GCed. (The
       * need to clear our reference to the TimeoutFuture is the reason we use a *static* nested
       * class with a manual reference back to the "containing" class.)
       *