}

    /**
     * Removes delimiters.
     *
     * @param value
     *            String value
     * @param locale
     *            Locale
     * @return String result with delimiters removed
     */
    public static String removeDelimeter(String value, final Locale locale) {
        final String groupingSeparator = findGroupingSeparator(locale);
        if (groupingSeparator != null) {

        // Assert
        assertEquals(0, result);
    }

    @Test
    @DisplayName("toString should return formatted string with pipe name")
    void testToString() {
        // Arrange
        transWaitNamedPipe = new TransWaitNamedPipe(mockConfig, testPipeName);

        // Act
        String result = transWaitNamedPipe.toString();

        // Assert
        assertNotNull(result);

  private static final class FloatConverter extends Converter<String, Float>
      implements Serializable {
    static final Converter<String, Float> INSTANCE = new FloatConverter();

    @Override
    protected Float doForward(String value) {
      return Float.valueOf(value);
    }

    @Override
    protected String doBackward(Float value) {
      return value.toString();
    }

    @Override

        super("ECL0072", asArray(getSql(cause), getRealMessage(cause), Integer.toString(cause.getErrorCode()), cause.getSQLState()), cause);
    }

    /**
     * Returns the <code>SQL</code>.
     *
     * @param cause the underlying exception
     * @return the <code>SQL</code>
     */
    protected static String getSql(final SQLException cause) {
        if (cause instanceof ClSQLException) {

        // Constructor should initialize the object without throwing exceptions
        assertNotNull(querySecurityDesc);

        // Test toString contains the expected values to verify field initialization
        String str = querySecurityDesc.toString();
        assertTrue(str.contains("fid=0x" + Hexdump.toHexString(fid, 4)));
        assertTrue(str.contains("securityInformation=0x" + Hexdump.toHexString(securityInfo, 8)));

                .directory(sourceRoot.directory().toString())
                .includes(sourceRoot.includes())
                .excludes(sourceRoot.excludes())
                .filtering(Boolean.toString(sourceRoot.stringFiltering()))
                .targetPath(sourceRoot.targetPath().map(Path::toString).orElse(null))
                .build());
        this.originalSourceRoot = sourceRoot;

      new ListenerCallQueue.Event<Object>() {
        @Override
        public void call(Object object) {
          throw new RuntimeException();
        }

        @Override
        public String toString() {
          return "throwing()";
        }
      };

  public void testEnqueueAndDispatch() {
    Object listener = new Object();
    ListenerCallQueue<Object> queue = new ListenerCallQueue<>();

      new ListenerCallQueue.Event<Object>() {
        @Override
        public void call(Object object) {
          throw new RuntimeException();
        }

        @Override
        public String toString() {
          return "throwing()";
        }
      };

  public void testEnqueueAndDispatch() {
    Object listener = new Object();
    ListenerCallQueue<Object> queue = new ListenerCallQueue<>();

        });
        return builder.toString();
    }

    public String getArraySuffix() {
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < arrayDimensions; i++) {
            builder.append("[]");
        }
        if (varargs) {
            builder.append("...");
        }
        return builder.toString();
    }

    public TypeMetaData addTypeArg(TypeMetaData typeArg) {

        // The toString method appends to super.toString(). We'll check the appended part.
        String expectedEnd = ",addrEntry=]";
        String actual = nameQueryResponse.toString();
        assertTrue(actual.endsWith(expectedEnd), "toString should end with ',addrEntry=]' when addrEntry is null");
        assertTrue(actual.startsWith("NameQueryResponse["), "toString should start with expected prefix");
    }