}
  }

  private static final class Collider {
    final int value;

    Collider(int value) {
      this.value = value;
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      return obj instanceof Collider && ((Collider) obj).value == value;
    }

    @Override
    public int hashCode() {
      return 1; // evil!
    }
  }

  /**
   * Associates {@code value} with {@code key} in this cache. If the cache previously contained a
   * value associated with {@code key}, the old value is replaced by {@code value}.
   *
   * <p>Prefer {@link #get(Object, Callable)} when using the conventional "if cached, return;
   * otherwise create, cache and return" pattern.
   *
   * @since 11.0
   */
  void put(K key, V value);

  /**

  }

  private static void assertCastFails(long value) {
    try {
      SignedBytes.checkedCast(value);
      fail("Cast to byte should have failed: " + value);
    } catch (IllegalArgumentException ex) {
      assertWithMessage(value + " not found in exception text: " + ex.getMessage())
          .that(ex.getMessage().contains(String.valueOf(value)))
          .isTrue();
    }
  }

  public void testCompare() {

     *
     * @param value1
     *            The first value
     * @param value2
     *            The second value
     * @param value3
     *            The third value
     * @param value4
     *            The fourth value
     * @param value5
     *            The fifth value
     */
    public Tuple5(final T1 value1, final T2 value2, final T3 value3, final T4 value4, final T5 value5) {
        this.value1 = value1;

        this.value1 = value1;
        this.value2 = value2;
        this.value3 = value3;
        this.value4 = value4;
    }

    /**
     * Returns the first value.
     *
     * @return The first value
     */
    public T1 getValue1() {
        return value1;
    }

    /**
     * Sets the first value.
     *
     * @param value1

    public void test_print_parameterSorting() {
        activityHelper.useEcsFormat = false;
        Map<String, String> params = new HashMap<>();
        params.put("z_param", "z_value");
        params.put("a_param", "a_value");
        params.put("m_param", "m_value");
        activityHelper.print("test", OptionalThing.empty(), params);
        String result = localLogMsg.get();

    for (StandardSystemProperty property : StandardSystemProperty.values()) {
      assertEquals(property.key() + "=" + property.value(), property.toString());
    }
  }

  public void testNoNullValues() {
    for (StandardSystemProperty property : StandardSystemProperty.values()) {
      // Even though the contract in System.getProperties() specifies that a value will exist for

   * over keys in the order they were first encountered in the input, and the values for each key
   * are iterated in the order they were encountered. If two values for the same key are {@linkplain
   * Object#equals equal}, the first value encountered is used.
   *
   * @throws NullPointerException if any key, value, or entry is null
   * @since 19.0
   */
  public static <K, V> ImmutableSetMultimap<K, V> copyOf(

    }

    // Test evaluate method with null parameter value
    public void test_evaluate_withNullParameterValue() {
        String template = "Value is: ${value}";
        Map<String, Object> paramMap = new HashMap<>();
        paramMap.put("value", null);

        Object result = scriptEngine.evaluate(template, paramMap);
        assertEquals("Value is: null", result);
    }

    val headers = headersOf("a", "b", "c", "d")
    assertFailsWith<IndexOutOfBoundsException> {
      headers.value(-1)
    }
    assertThat(headers.value(0)).isEqualTo("b")
    assertThat(headers.value(1)).isEqualTo("d")
    assertFailsWith<IndexOutOfBoundsException> {
      headers.value(2)
    }
  }