String unicodeBody = "{\"message\":\"こんにちは世界\"}";
        request.body(unicodeBody);

        assertEquals(unicodeBody, request.body());
    }

    @Test
    public void testParamWithUnicodeCharacters() {
        CurlRequest request = new CurlRequest(Method.GET, "https://example.com");

        // Param with unicode characters
        request.param("message", "こんにちは");

        assertNotNull(request);

        put(inputStream(), RepositoryPlugin.PutOptions())
        println("Deployed ${file.name}")
      }
    } catch (e: IllegalArgumentException) {
      if ("Jar does not have a symbolic name" in e.message!!) {
        println("Skipped non-OSGi dependency: ${file.name}")
        return
      }
      throw e
    }
  }

  companion object {
    val fileSystem = FileSystem.SYSTEM

     */
    protected String escapeValue(final String action) {
        return action.replace('\t', ' ');
    }

    /**
     * Outputs a log message using the statistics logger.
     *
     * @param buf the string buffer containing the log message
     */
    protected void log(final StringBuilder buf) {
        statsLogger.info(buf.toString());
    }

    /**

      if (logger.isLoggable(Level.SEVERE)) {
        logger.log(Level.SEVERE, message(context), exception);
      }
    }

    private static Logger logger(SubscriberExceptionContext context) {
      return Logger.getLogger(EventBus.class.getName() + "." + context.getEventBus().identifier());
    }

    private static String message(SubscriberExceptionContext context) {
      Method method = context.getSubscriberMethod();

        assertTrue(exception instanceof Exception);
        assertTrue(exception instanceof Throwable);
    }

    @Test
    public void test_getMessage() {
        // Test that getMessage returns null (no message set in constructor)
        UserRoleLoginException exception = new UserRoleLoginException(RootAction.class);
        assertNull(exception.getMessage());
    }

    @Test
    public void test_getCause() {

        .addEqualityGroup(wrapperFunction.apply(generator.newFreshProxy(interfaceType)))
        // TODO: add an overload to EqualsTester to print custom error message?
        .testEquals();
  }

  private static <T> void testToString(
      Class<T> interfaceType, Function<? super T, ? extends T> wrapperFunction) {

        is IllegalArgumentException -> {
          assertEquals("Android internal error", ioe.message)
        }

        is CertificateException -> {
          assertTrue(ioe.cause?.cause is IllegalArgumentException)
          assertEquals(
            true,
            ioe.cause
              ?.cause
              ?.message
              ?.startsWith("Invalid input to toASCII"),
          )
        }

            throw AssertionError("unsupported hashAlgorithm: ${pin.hashAlgorithm}")
          }
        }
      }
    }

    // If we couldn't find a matching pin, format a nice exception.
    val message =
      buildString {
        append("Certificate pinning failure!")
        append("\n  Peer certificate chain:")
        for (element in peerCertificates) {
          append("\n    ")

                                </div>
                            </div>
                            <div class="card-body">
                                <div>
                                    <la:info id="msg" message="true">
                                        <div class="alert alert-success">${msg}</div>
                                    </la:info>
                                    <la:errors property="_global"/>

                            </div>
                            <div class="card-body">
                                <div>
                                    <la:info id="msg" message="true">
                                        <div class="alert alert-success">${msg}</div>
                                    </la:info>
                                    <la:errors property="_global"/>