private final String justAfterNull;

    protected NullsBefore(String justAfterNull) {
      if (justAfterNull == null) {
        throw new NullPointerException();
      }

      this.justAfterNull = justAfterNull;
    }

    @Override
    public int compare(@Nullable String lhs, @Nullable String rhs) {
      if (lhs == rhs) {

        ImmutableMap.<String, Integer>builder().put("abc", 1).put("def", 2).put("ghi", 3).build();
    String toTest =
        MoreObjects.toStringHelper(new TestClass())
            .add("field1", "This is string.")
            .add("field2", Arrays.asList("abc", "def", "ghi"))
            .add("field3", map)
            .toString();
    String expected =
        "TestClass{"

    // keys are requested parameter names (treated as field name here)
    protected Map<String, Object> elementsAll; // lazy-loaded, then after not null
    protected Map<String, MultipartFormFile> elementsFile; // me too
    protected Map<String, String[]> elementsText; // me too

    // ===================================================================================

    protected void addChildUrlFromTagAttribute(final List<String> urlList, final URI uri, final String attrValue, final String encoding) {
        try {
            final String childUrlValue = attrValue.trim();
            final URI childUri = childUrlValue.startsWith("?") ? new URI(uri.toString() + childUrlValue) : uri.resolve(childUrlValue);
            final String u = encodeUrl(normalizeUrl(childUri.toString()), encoding);

    }

    @Test
    void testToString() {
        // Test toString with zterm = true
        String originalStringTrue = "HelloWorld";
        UnicodeString unicodeStringTrue = new UnicodeString(originalStringTrue, true);
        assertEquals(originalStringTrue, unicodeStringTrue.toString(), "toString should return original string with zterm");

        // Test toString with zterm = false

  // A simple type whose .toString() will return the same value each time, but without maintaining
  // a strong reference to that value.
  static class Key {
    private final int value;
    private WeakReference<String> toString;

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

    @Override
    public synchronized String toString() {
      String s;
      if (toString != null) {

        () -> Types.newParameterizedType(Map.class, String.class, Integer.class, Long.class));
  }

  public void testToString() {
    assertEquals(int[].class.getName(), Types.toString(int[].class));
    assertEquals(int[][].class.getName(), Types.toString(int[][].class));
    assertEquals(String[].class.getName(), Types.toString(String[].class));
    Type elementType = List.class.getTypeParameters()[0];

      return arithmetic.add(a, b);
    }

    @Override
    public String toString() {
      return arithmetic.toString();
    }
  }

  private interface ParameterTypesDifferent {
    void foo(
        String s,
        Runnable r,
        Number n,
        Iterable<?> it,
        boolean b,
        Equivalence<String> eq,
        Exception e,
        InputStream in,
        Comparable<?> c,

    String knownOutput = "8cbf764cbe2e4623d99a41354adfd390";

    Mac mac = Mac.getInstance("HmacMD5");
    mac.init(SHA1_KEY);
    assertEquals(knownOutput, HashCode.fromBytes(mac.doFinal()).toString());
    assertEquals(knownOutput, Hashing.hmacMd5(SHA1_KEY).newHasher().hash().toString());
  }

  public void testKnownInputs() throws Exception {
    String knownOutput = "9753980fe94daa8ecaa82216519393a9";

     *            The pattern string
     * @return The converted {@literal String}
     */
    public static String toString(final Object value, final String pattern) {
        return switch (value) {
        case null -> null;
        case String s -> s;
        case java.util.Date d -> toString(d, pattern);
        case Number n -> toString(n, pattern);
        case byte[] bytes -> Base64Util.encode(bytes);