if (mainMethod != null) {
        if (mainMethod.parameters.isEmpty()) {
          mainMethod.invoke(null)
        } else {
          mainMethod.invoke(null, arrayOf<String>())
        }
      } else {
        System.err.println("No main for $className")
      }
    } catch (ite: InvocationTargetException) {
      if (!expectedFailure(className, ite.cause!!)) {
        throw ite.cause!!
      }
    }
  }

        verify(mockReferralData).getPath();
    }

    @Test
    @DisplayName("Should get expiration")
    void testGetExpiration() {
        // Given
        long expiration = System.currentTimeMillis();
        when(mockReferralData.getExpiration()).thenReturn(expiration);

        // When
        long result = mockReferralData.getExpiration();

        // Then

 *   <li>{@link org.apache.maven.api.cache.CacheMetadata} - Configuration for cache behavior and lifecycle</li>
 * </ul>
 * <p>
 * The caching system supports different retention periods through {@link org.apache.maven.api.cache.CacheRetention}:
 * <ul>
 *   <li>PERSISTENT - Data persists across Maven invocations</li>

	"github.com/minio/minio/internal/bucket/bandwidth"
	"github.com/minio/minio/internal/logger"
)

// This file contains peer related notifications. For sending notifications to
// external systems, see event-notification.go

// NotificationSys - notification system.
type NotificationSys struct {
	peerClients    []*peerRESTClient // Excludes self
	allPeerClients []*peerRESTClient // Includes nil client for self
}

    for (path in fileSystem.list(directory)) {
      deployFile(path)
    }
  }

  private fun RepositoryPlugin.deployClassPath() {
    val classpath = System.getProperty("java.class.path")
    val entries =
      classpath
        .split(File.pathSeparator.toRegex())
        .dropLastWhile { it.isEmpty() }
        .toTypedArray()
    for (classPathEntry in entries) {

   | This is a list of authentication profiles, keyed by the server-id used within the system.
   | Authentication profiles can be used whenever maven must make a connection to a remote server.
   |-->
  <servers>
    <!-- server
     | Specifies the authentication information to use when connecting to a particular server, identified by
     | a unique name within the system (referred to by the 'id' attribute below).
     |

        .build(),
    )
    val startNanos = System.nanoTime()
    val connection = server.url("/").toUrl().openConnection()
    connection.doOutput = true
    connection.getOutputStream().write("ABCDEF".toByteArray(UTF_8))
    val inputStream = connection.getInputStream()
    assertThat(inputStream.read()).isEqualTo(-1)
    val elapsedNanos = System.nanoTime() - startNanos

        try {
            final PrintStream originalOutStream = System.out;
            final ByteArrayOutputStream outStream = new ByteArrayOutputStream();
            System.setOut(new PrintStream(outStream, true));
            final PrintStream originalErrStream = System.err;
            final ByteArrayOutputStream errStream = new ByteArrayOutputStream();
            System.setErr(new PrintStream(errStream, true));
            try {

        assertThat(ex.getMessageCode(), is("ECL0001"));
        assertThat(ex.getArgs().length, is(1));
        assertThat(ex.getArgs()[0], is((Object) "hoge"));
        System.out.println(ex.getMessage());
    }

    /**
     * @throws Exception
     */
    @Test
    public void testGetCause() throws Exception {
        final Throwable t = new NullPointerException("test");

    public void testRelativePath() throws Exception {
        final File f = new File("/Program Files/foo.jar");
        URL url = new URL("jar:" + f.toURI().toURL() + "!/foo/bar/");
        url = new URL(url, "..");
        System.out.println(url.toExternalForm());
    }