CharMappingItem item4 = new CharMappingItem(4L, inputs1, "different");

        // Same inputs and output should have same hash code
        assertEquals(item1.hashCode(), item2.hashCode());

        // Different inputs should have different hash code
        assertNotSame(item1.hashCode(), item3.hashCode());

        // Same inputs but different output should have different hash code

    }
  }

  /**
   * Returns a hash code, having the same bit length as each of the input hash codes, that combines
   * the information of these hash codes in an ordered fashion. That is, whenever two equal hash
   * codes are produced by two calls to this method, it is <i>as likely as possible</i> that each
   * was computed from the <i>same</i> input hash codes in the <i>same</i> order.
   *

   * even in the same order. (It is guaranteed to return true for instances constructed from the
   * same values in the same order if {@code strictfp} is in effect, or if the system architecture
   * guarantees {@code strictfp}-like semantics.)
   */
  @Override
  public boolean equals(@Nullable Object obj) {
    if (obj == null) {
      return false;
    }
    if (getClass() != obj.getClass()) {
      return false;
    }

 *
 * <p><b>Warning:</b> instances of type {@code Multimap} may not implement {@link Object#equals} in
 * the way you expect. Multimaps containing the same key-value pairs, even in the same order, may or
 * may not be equal and may or may not have the same {@code hashCode}. The recommended subinterfaces
 * provide much stronger guarantees.
 *
 * <h3>Comparison to a map of collections</h3>
 *

    }

    // Test providePrimaryInvertibleCryptographer
    public void test_providePrimaryInvertibleCryptographer() {
        // Test that the method returns the same instance
        InvertibleCryptographer first = securityResourceProvider.providePrimaryInvertibleCryptographer();
        InvertibleCryptographer second = securityResourceProvider.providePrimaryInvertibleCryptographer();

   * safe to do so. The exact circumstances under which a copy will or will not be performed are
   * undocumented and subject to change.
   *
   * @throws IllegalArgumentException if two keys have the same value or two values have the same
   *     key
   * @throws NullPointerException if any key or value in {@code map} is null
   */

    /**
     * Add a header with the specified name and value. Does validation of header names and values.
     */
    fun add(
      name: String,
      value: String,
    ) = commonAdd(name, value)

    /**
     * Add a header with the specified name and value. Does validation of header names, allowing
     * non-ASCII values.
     */
    fun addUnsafeNonAscii(
      name: String,
      value: String,

    // enclosed with same start
    assertEquals(range, range.span(Range.closed(4, 6)));

    // enclosed, interior
    assertEquals(range, range.span(Range.closed(5, 7)));

    // enclosed with same end
    assertEquals(range, range.span(Range.closed(6, 8)));

    // equal
    assertEquals(range, range.span(range));

    // enclosing with same start

        StopwordsItem item2 = new StopwordsItem(1, "test");
        StopwordsItem item3 = new StopwordsItem(2, "test");
        StopwordsItem item4 = new StopwordsItem(1, "different");

        // Same input should have same hashCode regardless of id
        assertEquals(item1.hashCode(), item2.hashCode());
        assertEquals(item1.hashCode(), item3.hashCode());

        // Different input should have different hashCode

        return new IllegalArgumentException(
            "Multiple entries with same key: " + key + "=" + value1 + " and " + key + "=" + value2);
      }
    }
  }

  /**
   * Returns an immutable map containing the same entries as {@code map}. The returned map iterates
   * over entries in the same order as the {@code entrySet} of the original map. If {@code map}