assertEquals(entry.getKey() + "=" + entry.getValue(), entry.toString());
    }

    assertEquals("{" + JOINER.join(map.entrySet()) + "}", map.toString());
    assertEquals("[" + JOINER.join(map.entrySet()) + "]", map.entrySet().toString());
    assertEquals("[" + JOINER.join(map.keySet()) + "]", map.keySet().toString());
    assertEquals("[" + JOINER.join(map.values()) + "]", map.values().toString());

        // Then
        String toString = provider.toString();
        assertNotNull(toString);
        assertTrue("toString should contain TimeZone ID", toString.contains(FessUserTimeZoneProcessProvider.centralTimeZone.getID()));
        // The provider's toString might not contain the exact class name
        // Just verify it's not null and contains some meaningful info
        assertTrue("toString should not be empty", toString.length() > 0);

                if (queryBuilder instanceof final TermsQueryBuilder termsQueryBuilder) {
                    termsQueryBuilder.values().stream().forEach(o -> deletedDocIdList.add(o.toString()));
                }
                return deletedDocIdList.size();
            }
        };
        ComponentUtil.register(client, "searchEngineClient");
        final DocList docList = new DocList();

      p++;
    }
    if (validSurrogatePairAt(a, p - 1) || validSurrogatePairAt(b, p - 1)) {
      p--;
    }
    return a.subSequence(0, p).toString();
  }

  /**
   * Returns the longest string {@code suffix} such that {@code a.toString().endsWith(suffix) &&
   * b.toString().endsWith(suffix)}, taking care not to split surrogate pairs. If {@code a} and
   * {@code b} have no common suffix, returns the empty string.
   *

  // 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) {

        String message = "Test error message";
        CurlException exception = new CurlException(message);
        String toString = exception.toString();

        assertNotNull(toString);
        assertTrue(toString.contains("CurlException"));
        assertTrue(toString.contains(message));
    }

    @Test
    public void testStackTrace() {

    }

    @Test
    @DisplayName("toString includes information level in hex")
    void testToString() {
        int level = 0xABC;
        Trans2QueryFSInformation cmd = new Trans2QueryFSInformation(level);
        String str = cmd.toString();
        // toString uses Hexdump.toHexString(informationLevel, 3)
        assertTrue(str.contains(Hexdump.toHexString(level, 3)), "toString should contain hex level");

                "description");
        setupEpg(_epgMap, et -> ((WebConfig) et).getExcludedDocUrls(),
                (et, vl) -> ((WebConfig) et).setExcludedDocUrls(DfTypeUtil.toString(vl)), "excludedDocUrls");
        setupEpg(_epgMap, et -> ((WebConfig) et).getExcludedUrls(), (et, vl) -> ((WebConfig) et).setExcludedUrls(DfTypeUtil.toString(vl)),
                "excludedUrls");

    }

    @Test
    @DisplayName("toString should return formatted string")
    void testToString() {
        // Act
        String result = response.toString();

        // Assert
        assertNotNull(result);
        assertTrue(result.contains("TransWaitNamedPipeResponse["));
        assertTrue(result.endsWith("]"));
    }

    @Test
    @DisplayName("toString should include parent class information")

    // Two futures should not have the same toString, to avoid people asserting on it
    assertThat(SettableFuture.create().toString()).isNotEqualTo(SettableFuture.create().toString());
  }

  public void testToString_oom() throws Exception {
    SettableFuture<Object> future = SettableFuture.create();
    future.set(
        new Object() {
          @Override
          public String toString() {
            throw new OutOfMemoryError();