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();

        Nothing::class to Adapters.PRINTABLE_STRING,
        AnyValue::class to Adapters.ANY_VALUE,
      ),
      decompose = {
        listOf(
          it.type,
          it.value,
        )
      },
      construct = {
        AttributeTypeAndValue(
          type = it[0] as String,
          value = it[1],
        )
      },
    )

  /**
   * ```

        ldapManager.init();

        // Null byte should be escaped to \00
        assertEquals("\\00", ldapManager.escapeLDAPSearchFilter("\0"));
        assertEquals("test\\00value", ldapManager.escapeLDAPSearchFilter("test\0value"));
    }

    @Test
    public void test_escapeLDAPSearchFilter_withComplexInjectionAttempt() {
        LdapManager ldapManager = new LdapManager();
        ldapManager.init();

    helper.addValue(2);
    assertThat(helper.toString()).isEqualTo(expected2);
  }

  @GwtIncompatible // Class names are obfuscated in GWT
  public void testToString_addValue() {
    String toTest =
        MoreObjects.toStringHelper(new TestClass())
            .add("field1", 1)
            .addValue("value1")
            .add("field2", "value2")
            .addValue(2)
            .toString();

        return ((CharSequence) value).length() == 0;
      } else if (value instanceof Collection) {
        return ((Collection<?>) value).isEmpty();
      } else if (value instanceof Map) {
        return ((Map<?, ?>) value).isEmpty();
      } else if (value instanceof Optional) {
        return !((Optional) value).isPresent();
      } else if (value.getClass().isArray()) {

    BigDecimal maxDoubleAsBigDecimal = new BigDecimal(Double.MAX_VALUE);
    new RoundToDoubleTester(maxDoubleAsBigDecimal)
        .setExpectation(Double.MAX_VALUE, RoundingMode.values())
        .test();
  }

  public void testRoundToDouble_maxDoublePlusOne() {
    BigDecimal maxDoubleAsBigDecimal = new BigDecimal(Double.MAX_VALUE).add(BigDecimal.ONE);
    new RoundToDoubleTester(maxDoubleAsBigDecimal)

  }

  /**
   * Returns the closest representable {@code int} to the absolute value of {@code x}.
   *
   * <p>This is the same thing as the true absolute value of {@code x} except in the case when
   * {@code x} is {@link Integer#MIN_VALUE}, in which case this returns {@link Integer#MAX_VALUE}.
   * (Note that {@code Integer.MAX_VALUE} is mathematically equal to {@code -Integer.MIN_VALUE -
   * 1}.)
   *

  static final int[] LARGE_INTEGER_VALUES = {Integer.MAX_VALUE, Integer.MAX_VALUE / 2};
  static final double LARGE_INTEGER_VALUES_MEAN =
      BigInteger.valueOf(Integer.MAX_VALUE)
          .multiply(BigInteger.valueOf(3L))
          .divide(BigInteger.valueOf(4L))
          .doubleValue();
  static final double LARGE_INTEGER_VALUES_POPULATION_VARIANCE =
      BigInteger.valueOf(Integer.MAX_VALUE)

    HONDA,
    POODLE,
  }

  public void testGetIfPresent() {
    assertThat(Enums.getIfPresent(TestEnum.class, "CHEETO")).hasValue(TestEnum.CHEETO);
    assertThat(Enums.getIfPresent(TestEnum.class, "HONDA")).hasValue(TestEnum.HONDA);
    assertThat(Enums.getIfPresent(TestEnum.class, "POODLE")).hasValue(TestEnum.POODLE);

    assertThat(Enums.getIfPresent(TestEnum.class, "CHEETO")).isPresent();

    return generateListMultimap(key, value);
  }

  @Generates
  static <K, V> ImmutableMultimap<K, V> generateImmutableMultimap(K key, V value) {
    return ImmutableMultimap.of(key, value);
  }

  @Generates
  static <K, V> ListMultimap<K, V> generateListMultimap(@Nullable K key, @Nullable V value) {
    return generateArrayListMultimap(key, value);
  }

  @Generates