mockExcludePatterns.add(Pattern.compile("https://example.com/private/.*"));
        mockExcludePatterns.add(Pattern.compile("https://example.com/secret/.*"));

        when(dataHelper.getIncludeUrlPatternList(sessionId)).thenReturn(mockIncludePatterns);
        when(dataHelper.getExcludeUrlPatternList(sessionId)).thenReturn(mockExcludePatterns);

        // Execute retrieval

 */
package org.codelibs.fess.exception;

import org.codelibs.fess.opensearch.config.exentity.ScheduledJob;

/**
 * Exception thrown when a scheduled job cannot be found.
 * This exception is typically thrown when attempting to access or
 * manipulate a job that does not exist in the system.
 */
public class JobNotFoundException extends FessSystemException {

repository. During development in an IDE we would need layered resolution approach that would allow resolution from the workspace, then the local Maven repository and then from any number of remote Maven repositories. During development from the command line we would need a layered resolution approach that would allow resolution from the local Maven repository and then from any number of remote Maven repositories. In production the resolution for the dependencies could also be layered but would depend...

      }

      else -> {
        toEvict = null
        toEvictIdleAtNs = -1L
      }
    }

    when {
      toEvict != null -> {
        // We've chosen a connection to evict. Confirm it's still okay to be evicted, then close it.
        toEvict.withLock {
          if (toEvict.calls.isNotEmpty()) return 0L // No longer idle.

A **`Session`** is what stores the **objects in memory** and keeps track of any changes needed in the data, then it **uses the `engine`** to communicate with the database.

We will create a FastAPI **dependency** with `yield` that will provide a new `Session` for each request. This is what ensures that we use a single session per request. 🤓

Then we create an `Annotated` dependency `SessionDep` to simplify the rest of the code that will use this dependency.

internal fun String.indexOfFirstNonAsciiWhitespace(
  startIndex: Int = 0,
  endIndex: Int = length,
): Int {
  for (i in startIndex until endIndex) {
    when (this[i]) {
      '\t', '\n', '\u000C', '\r', ' ' -> Unit
      else -> return i
    }
  }
  return endIndex
}

/**

    @DisplayName("getPreNTLMResponse: uses OEM bytes, truncates to 14, verifies interactions")
    void testGetPreNTLMResponse_basicAndInteractions() throws Exception {
        // Arrange
        when(cifsContext.getConfig()).thenReturn(configuration);
        when(configuration.getOemEncoding()).thenReturn("Cp850");
        String password14 = "ABCDEFGHIJKLMN"; // 14 chars
        String password15 = "ABCDEFGHIJKLMNO"; // 15 chars, same first 14

### Disable the automatic docs for static files { #disable-the-automatic-docs-for-static-files }

The same as when using a custom CDN, the first step is to disable the automatic docs, as those use the CDN by default.

To disable them, set their URLs to `None` when creating your `FastAPI` app:

{* ../../docs_src/custom_docs_ui/tutorial002_py39.py hl[9] *}

    requestHeaders: List<Header>,
  ): Boolean

  /**
   * The response headers corresponding to a pushed request.  When [last] is true, there are
   * no data frames to follow.
   *
   * @param streamId server-initiated stream ID: an even number.
   * @param responseHeaders minimally includes `:status`.
   * @param last when true, there is no response data.
   */
  fun onHeaders(
    streamId: Int,
    responseHeaders: List<Header>,

import java.util.LinkedHashMap;
import org.jspecify.annotations.Nullable;

/**
 * A {@code Multiset} implementation with predictable iteration order. Its iterator orders elements
 * according to when the first occurrence of the element was added. When the multiset contains
 * multiple instances of an element, those instances are consecutive in the iteration order. If all