*/
    public DefaultCorsHandler() {
        super();
    }

    /**
     * Registers this CORS handler with the factory for configured allowed origins.
     * This method is automatically called after bean initialization.
     */
    @PostConstruct
    public void register() {
        final CorsHandlerFactory factory = ComponentUtil.getCorsHandlerFactory();

bsbhv     : base behaviors
bsentity  : base entities
cbean     : condition-beans (both base and extended)
exbhv     : extended behaviors
exentity  : extended entities
- - - - - - - - - -/

For example, if a table called "MEMBER" exists,
you can use these classes like this:
/- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
memberBhv.selectEntity(cb -> {
    cb.query().setMemberId_Equal(3);
}).alwaysPresent(member -> {

            }

            // Verify that calculateMIC was never called
            verify(mockCtx, never()).calculateMIC(any());
            // Verify that supportsIntegrity was checked once
            verify(mockCtx, times(1)).supportsIntegrity();
            // Due to short-circuit evaluation, isEstablished should never be called
            // when supportsIntegrity returns false

          executor.execute(
              () -> {
                try {
                  startUp();
                  notifyStarted();
                  // If stopAsync() is called while starting we may be in the STOPPING state in
                  // which case we should skip right down to shutdown.
                  if (isRunning()) {
                    try {

   *   <li>{@link Cancellation} terminal state, {@code cancel} was called.
   *   <li>{@link Failure} terminal state, {@code setException} was called.
   *   <li>{@link DelegatingToFuture} intermediate state, {@code setFuture} was called.
   *   <li>{@link #NULL} terminal state, {@code set(null)} was called.
   *   <li>Any other non-null value, terminal state, {@code set} was called with a non-null
   *       argument.
   * </ul>
   */

   * types your try block can throw when calling an overload of this method so as to avoid losing
   * the original exception type.
   *
   * <p>This method always throws, and as such should be called as {@code throw closer.rethrow(e);}
   * to ensure the compiler knows that it will throw.
   *
   * @return this method does not return; it always throws
   * @throws IOException when the given throwable is an IOException

    }

    /**
     * Test for close() method.
     * Verifies that the close method can be called without throwing an exception.
     * @throws CIFSException
     */
    @Test
    void testClose() throws CIFSException {
        smbTreeHandle.close();
        // Verify that close() was called on the mock
        verify(smbTreeHandle).close();
    }

    /**

        // and a mock SmbFile with specific attributes
        when(mockFile.getAttributes()).thenReturn(fileAttributes);

        // When the accept method is called
        boolean result = dosFileFilter.accept(mockFile);

        // Then the result should be as expected
        if (expectedResult) {
            assertTrue(result, "File should be accepted");
        } else {

    parameter to be non-null was an unintended signature change in OkHttp 4.0.

 *  New: `EventListener.retryDecision()` is called each time a request fails with an `IOException`.
    It notifies your listener if OkHttp will retry.

 *  New: `EventListener.followUpDecision()` is called each time a response is received. It notifies
    your listener if OkHttp has decided to make a follow-up request. Some common follow-ups are

   *
   * <p>If a character has no mapped replacement then it is checked against the safe range. If it
   * lies outside that, then {@link #escapeUnsafe} is called, otherwise no escaping is performed.
   *
   * @param replacementMap a map of characters to their escaped representations
   * @param safeMin the lowest character value in the safe range