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

  public void testFailsToForwardToString() {
    assertFailure(
        Runnable.class,
        runnable ->
            new ForwardingRunnable(runnable) {
              @Override
              public String toString() {
                return "";
              }

        DfsReferral dfsReferral = new DfsReferral(mockData);

        // Verify that toString() returns the expected string from the mock data object
        assertEquals(expectedToString, dfsReferral.toString(),
                "toString() should return the result of the wrapped DfsReferralData's toString() method.");
    }

        assertNull(ex.getCause());

        // Assert - toString starts with class name and contains message when present
        if (message == null) {
            assertEquals(SMBProtocolDowngradeException.class.getName(), ex.toString());
        } else if (message.isEmpty()) {
            // Throwable.toString prints class + ": " (with space) even for empty string

    assertThat(helper.toString()).isEqualTo(expected);
    // Call toString again
    assertThat(helper.toString()).isEqualTo(expected);

    // Make sure the cached value is reset when we modify the helper at all
    String expected2 = "TestClass{field1=1, value1, field2=value2, 2}";
    helper.addValue(2);
    assertThat(helper.toString()).isEqualTo(expected2);
  }

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

    Checksum checksum = supplier.get();
    checksum.update(bytes, 0, bytes.length);
    long value = checksum.getValue();

    String toString = "name";
    HashFunction func = new ChecksumHashFunction(supplier, 32, toString);
    assertThat(func.toString()).isEqualTo(toString);
    assertEquals(value, func.hashBytes(bytes).padToLong());
  }

  private static void assertHash32(

    assertThat(ourType1.toString()).isEqualTo(jvmType1.toString());
    assertThat(ourType2.toString()).isEqualTo(jvmType2.toString());
  }

  public void testNewArrayTypeOfArray() {
    Type jvmType = new TypeCapture<int[][]>() {}.capture();
    Type ourType = Types.newArrayType(int[].class);
    assertThat(ourType.toString()).isEqualTo(jvmType.toString());

        final long docFreq = Long.parseLong(source.get(FieldNames.DOC_FREQ).toString());
        final long queryFreq = Long.parseLong(source.get(FieldNames.QUERY_FREQ).toString());
        final float userBoost = Float.parseFloat(source.get(FieldNames.USER_BOOST).toString());
        final List<String> tags = SuggestUtil.getAsList(source.get(FieldNames.TAGS));

        Exception exception = new RuntimeException("Test error message");

        monitorTarget.appendException(buf, exception);
        assertTrue(buf.toString().startsWith("\"exception\":\""));
        assertTrue(buf.toString().contains("Test error message"));
        assertTrue(buf.toString().contains("RuntimeException"));
    }

    // Test appendException method with nested exception
    @Test

  public void testToString_minimal() {
    assertNotNull("toString() should not return null", getMap().toString());
  }

  @CollectionSize.Require(ZERO)
  @CollectionFeature.Require(absent = NON_STANDARD_TOSTRING)
  public void testToString_size0() {
    assertEquals("emptyMap.toString should return {}", "{}", getMap().toString());
  }

  @CollectionSize.Require(ONE)