this.repositorySystemProvider = requireNonNull(repositorySystemProvider);
    }

    @PreDestroy
    public void shutdown() {
        repositorySystemProvider.get().shutdown();
    }

   * message buffer (16 MiB) will be rejected and trigger a [graceful shutdown][close] of this web
   * socket. This method returns false in that case, and in any other case where this web socket is
   * closing, closed, or canceled.
   *
   * This method returns immediately.
   */
  fun send(bytes: ByteString): Boolean

  /**
   * Attempts to initiate a graceful shutdown of this web socket. Any already-enqueued messages will

 * the "running" state need to perform a periodic task. Subclasses can implement {@link #startUp},
 * {@link #shutDown} and also a {@link #runOneIteration} method that will be executed periodically.
 *
 * <p>This class uses the {@link ScheduledExecutorService} returned from {@link #executor} to run
 * the {@link #startUp} and {@link #shutDown} methods and also uses that service to schedule the

	natsserver "github.com/nats-io/nats-server/v2/test"
)

func TestNatsConnPlain(t *testing.T) {
	opts := natsserver.DefaultTestOptions
	opts.Port = 14222
	s := natsserver.RunServer(&opts)
	defer s.Shutdown()

	clientConfig := &NATSArgs{
		Enable: true,
		Address: xnet.Host{
			Name:      "localhost",
			Port:      (xnet.Port(opts.Port)),
			IsPortSet: true,
		},
		Subject: "test",
	}

        .build()
    url =
      serverIpv4.url("/")
        .newBuilder()
        .host("localhost")
        .build()
  }

  @AfterEach
  internal fun tearDown() {
    serverIpv4.shutdown()
    serverIpv6.shutdown()
  }

  @Test
  fun callIpv6FirstEvenWhenIpv4IpIsListedFirst() {
    dnsResults =
      listOf(
        localhostIpv4,
        localhostIpv6,
      )
    serverIpv4.enqueue(

                while ( !this.started ) {
                    this.startedLock.wait();
                }
            }
        }


        public void shutdown () {
            this.shutdown = true;
            synchronized ( this.shutdownLock ) {
                this.shutdownLock.notify();
            }
        }


        /**
         * {@inheritDoc}
         *

# Testing Events: startup - shutdown

When you need your event handlers (`startup` and `shutdown`) to run in your tests, you can use the `TestClient` with a `with` statement:

```Python hl_lines="9-12  20-24"
{!../../docs_src/app_testing/tutorial003.py!}

                  // which case we should skip right down to shutdown.
                  if (isRunning()) {
                    try {
                      AbstractExecutionThreadService.this.run();
                    } catch (Throwable t) {
                      restoreInterruptIfIsInterruptedException(t);
                      try {
                        shutDown();
                      } catch (Exception ignored) {

    assertFalse(testExecutor.isTerminated());
    mock.assertLastMethodCalled("isTerminated");
    assertFalse(testExecutor.isShutdown());
    mock.assertLastMethodCalled("isShutdown");
    testExecutor.shutdown();
    mock.assertLastMethodCalled("shutdown");
    List<Runnable> list = testExecutor.shutdownNow();
    mock.assertLastMethodCalled("shutdownNow");
    assertEquals(ImmutableList.of(), list);
  }

### `shutdown`-Event

Um eine Funktion hinzuzufügen, die beim Herunterfahren der Anwendung ausgeführt werden soll, deklarieren Sie sie mit dem Event `shutdown`:

```Python hl_lines="6"
{!../../docs_src/events/tutorial002.py!}
```

Hier schreibt die `shutdown`-Eventhandler-Funktion eine Textzeile `"Application shutdown"` in eine Datei `log.txt`.

/// info