else -> {
      logger.info("Module-info checking is disabled")
    }
  }
  // Set the task outputs and destination dir
  outputs.dir(targetDir)
  destinationDirectory.set(targetDir)

  // Configure JVM compatibility
  sourceCompatibility = JavaVersion.VERSION_1_9.toString()
  targetCompatibility = JavaVersion.VERSION_1_9.toString()

  // Set the Java release version.
  options.release.set(9)

# Conditional OpenAPI { #conditional-openapi }

If you needed to, you could use settings and environment variables to configure OpenAPI conditionally depending on the environment, and even disable it entirely.

## About security, APIs, and docs { #about-security-apis-and-docs }

Hiding your documentation user interfaces in production *shouldn't* be the way to protect your API.

public class ResourceManagerTest {

    private ResourceManager resourceManager;

    @BeforeEach
    void setUp() {
        resourceManager = ResourceManager.getInstance();
        // Configure with shorter intervals for testing
        resourceManager.configure(1000, 100, true, true);
    }

    /**
     * Test resource for tracking
     */
    static class TestResource implements AutoCloseable {

        serverData.encryptionKey = new byte[8];

        // Configure mock transport
        mockTransport.server = serverData;
        mockTransport.sessionKey = 0x12345678;
        mockTransport.capabilities = SmbConstants.CAP_UNICODE | SmbConstants.CAP_NT_SMBS;
        mockTransport.snd_buf_size = 16644;
        mockTransport.maxMpxCount = 50;

        // Configure mock session
        mockSession.transport = mockTransport;

        verify(dcerpcSecurityProvider, times(1)).wrap(mockNdrBuffer);
    }

    @Test
    void testWrapMethodThrowsDcerpcException() throws DcerpcException {
        // Configure the mock to throw DcerpcException when wrap is called
        doThrow(new DcerpcException("Test wrap exception")).when(dcerpcSecurityProvider).wrap(mockNdrBuffer);

        // Assert that calling wrap throws DcerpcException

import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.apache.maven.api.annotations.Experimental;
import org.apache.maven.api.annotations.Nonnull;

/**
 * Used to configure your Mojo parameters to be injected by
 * <a href="/ref/current/maven-core/apidocs/org/apache/maven/plugin/MavenPluginManager.html">
 * <code>MavenPluginManager.getConfiguredMojo(...)</code></a>.
 * <p>

It would probably all start by you **acquiring** some **domain name**. Then, you would configure it in a DNS server (possibly your same cloud provider).

You would probably get a cloud server (a virtual machine) or something similar, and it would have a <abbr title="That doesn't change">fixed</abbr> **public IP address**.

In the DNS server(s) you would configure a record (an "`A record`") to point **your domain** to the public **IP address of your server**.

            container.discoverComponents(
                    extension.entry().getClassRealm(),
                    new AbstractModule() {
                        @Override
                        protected void configure() {
                            try {
                                container
                                        .lookup(Injector.class)

# Path Operation Configuration { #path-operation-configuration }

There are several parameters that you can pass to your *path operation decorator* to configure it.

/// warning

Notice that these parameters are passed directly to the *path operation decorator*, not to your *path operation function*.

///

## Response Status Code { #response-status-code }

You can define the (HTTP) `status_code` to be used in the response of your *path operation*.

        fillMojoDescriptor(session, project, mojoExecution);

        mojoExecutionConfigurator(mojoExecution)
                .configure(project, mojoExecution, MojoExecution.Source.CLI.equals(mojoExecution.getSource()));

        finalizeMojoConfiguration(mojoExecution);