}

    /**
     * Test toString method behavior - requires valid configuration
     */
    @Test
    @DisplayName("Test toString requires valid configuration")
    public void testToStringRequiresValidConfig() {
        // Constructor with null config throws exception, so we can't test toString with null config
        // Instead, test that toString works with a valid config

        // Given

        assertEquals(info1.toString(), info2.toString());
    }

    @Test
    @DisplayName("Test encode does not modify source object")
    void testEncodeImmutability() {
        long originalValue = 1000L;
        FileEndOfFileInformation info = new FileEndOfFileInformation(originalValue);

        // Get original toString
        String originalString = info.toString();

        // Encode

     */
    public static String toString(final Object value) {
        return toString(value, null);
    }

    /**
     * Converts the given object to a string.
     *
     * @param value
     *            The object to convert
     * @param pattern
     *            The pattern string
     * @return The converted {@literal String}
     */
    public static String toString(final Object value, final String pattern) {

  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)

  get() = findProperty("okhttp.platform")?.toString() ?: "jdk9"

val Project.testJavaVersion: Int
  get() = findProperty("test.java.version")?.toString()?.toInt() ?: 21

val Project.androidBuild: Boolean
  get() = findProperty("androidBuild")?.toString()?.toBoolean() ?: false

val Project.alpnBootVersion: String?

        assertTrue(ex instanceof SmbException, "Should be an SmbException");

        // toString should include the class name and the message
        String ts = ex.toString();
        assertTrue(ts.contains("SmbUnsupportedOperationException"), "toString should contain class name");
        assertTrue(ts.contains(ex.getMessage()), "toString should contain the detail message");
    }

    @ParameterizedTest(name = "Message preserved: [{0}]")

        Map<String, Object> source;
        while ((source = reader.read()) != null) {
            assertTrue(source.get("field1").toString().startsWith("test"));
            valueSet.add(source.get("field1").toString());
            count++;
        }
        assertEquals(num, count);
        assertEquals(num, valueSet.size());
    }

    @Test

        assertEquals("_default:fess", ((TermQuery) query).toString());

        query = queryParser.createDefaultFilterChain().parse("\"fess codelibs\"");
        assertEquals(PhraseQuery.class, query.getClass());
        assertEquals("_default:fess", ((PhraseQuery) query).getTerms()[0].toString());
        assertEquals("_default:codelibs", ((PhraseQuery) query).getTerms()[1].toString());

 * @author Jared Levy
 * @since 2.0
 */
@GwtCompatible
public final class Functions {
  private Functions() {}

  /**
   * A function equivalent to the method reference {@code Object::toString}. The function simply
   * invokes {@code toString} on its argument and returns the result. It throws a {@link
   * NullPointerException} on null input.
   *
   * <p><b>Warning:</b> The returned function may not be <i>consistent with equals</i> (as

        String infoString = info.toString();
        assertTrue(infoString.contains("alloc=1000"), "toString should contain alloc");
        assertTrue(infoString.contains("free=500"), "toString should contain free");
        assertTrue(infoString.contains("sectPerAlloc=100"), "toString should contain sectPerAlloc");
        assertTrue(infoString.contains("bytesPerSect=512"), "toString should contain bytesPerSect");
    }