// Lease completely broken - invalidate cache
            entry.invalidate();
        }

        if ((newState & Smb2LeaseState.SMB2_LEASE_HANDLE_CACHING) == 0) {
            // Lost handle cache - may need to close directory handle
            changeNotifier.stopWatching(directoryPath);
        }

        // Forward to base lease manager
        baseLeaseManager.handleLeaseBreak(leaseKey, newState);
    }

    }

    @Test
    @DisplayName("Should handle null message")
    void testNullMessage() {
        // When/Then
        assertDoesNotThrow(() -> {
            CIFSException exception = new CIFSException((String) null);
            assertNotNull(exception);
        });
    }

    @Test
    @DisplayName("Should handle null cause")
    void testNullCause() {
        // When/Then

            assertArrayEquals(new int[] { 1, 2 }, context.getHashAlgos());
            assertArrayEquals(new byte[] { 0x0A, 0x0B, 0x0C, 0x0D }, context.getSalt());
        }

        @Test
        @DisplayName("Should handle empty arrays in decode")
        void testDecodeEmptyArrays() throws SMBProtocolDecodingException {
            // Arrange
            context = new PreauthIntegrityNegotiateContext();

        @Test
        @DisplayName("Should handle empty buffer encoding")
        void testEmptyBufferEncoding() {
            byte[] buffer = new byte[256];
            testMessage.setBytesWritten(0);
            int len = testMessage.encode(buffer, 0);
            assertTrue(len >= Smb2Constants.SMB2_HEADER_LENGTH);
        }

        @Test
        @DisplayName("Should handle large MID values")

        System.out.println("serving docs at http://localhost:" + getPort().get());
        DeploymentRegistry registry = getDeploymentRegistry();
        JavaApplicationHandle handle = registry.get(getPath(), JavaApplicationHandle.class);
        if (handle == null) {
            JavaExecHandleBuilder builder = getExecActionFactory().newJavaExec();
            builder.setExecutable(getJavaLauncher().get().getExecutablePath().getAsFile());

            assertEquals(0, result.errorPoms().size(), "Should have no errors");
        }

        @Test
        @DisplayName("should handle strategy failures gracefully")
        void shouldHandleStrategyFailuresGracefully() throws Exception {
            UpgradeContext context = createMockContext();

 */
package org.codelibs.fess.job;

/**
 * Abstract base class for job executors that handle script execution within the job system.
 * This class provides a framework for executing scripts and managing shutdown operations.
 */
public abstract class JobExecutor {
    /** Listener to handle shutdown events */
    protected ShutdownListener shutdownListener;

    /**
     * Default constructor.
     */

Some of the options you could use as a TLS Termination Proxy are:

* Traefik (that can also handle certificate renewals)
* Caddy (that can also handle certificate renewals)
* Nginx
* HAProxy

## Let's Encrypt { #lets-encrypt }

Before Let's Encrypt, these **HTTPS certificates** were sold by trusted third parties.

# Security { #security }

There are many ways to handle security, authentication and authorization.

And it normally is a complex and "difficult" topic.

In many frameworks and systems just handling security and authentication takes a big amount of effort and code (in many cases it can be 50% or more of all the code written).

        System.arraycopy(buffer, bodyOffset + 8, actualPath, 0, pathBytes.length);
        assertArrayEquals(pathBytes, actualPath);
    }

    @Test
    @DisplayName("Should handle chain operation correctly")
    void testChain() {
        // Given
        ServerMessageBlock2 nextMessage = mock(ServerMessageBlock2.class);

        // When
        boolean result = request.chain(nextMessage);