private LdapChain ldapChain;
    private TestLdapManager testLdapManager;
    private TestFessConfig testFessConfig;

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);
        ldapChain = new LdapChain();
        testLdapManager = new TestLdapManager();
        testFessConfig = new TestFessConfig();

      assertBitEquals(x, at.get());
      prev = x;
    }
  }

  /** compareAndSet in one thread enables another waiting for value to succeed */
  public void testCompareAndSetInMultipleThreads() throws Exception {
    AtomicDouble at = new AtomicDouble(1.0);
    Thread t =
        newStartedThread(
            new CheckedRunnable() {
              @Override

   *
   * <p>Note: This default implementation is overkill (but valid) for an unordered container. An
   * equally valid implementation for an unordered container is to throw an exception. The chosen
   * implementation, however, has the advantage of working for insertion-ordered containers, as
   * well.
   */
  @Override
  public List<Integer> order(List<Integer> insertionOrder) {

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

/**
 *
 * @since 4.0.0
 */
@Experimental
public interface VersionResolverResult extends Result<VersionResolverRequest> {

    @Nonnull
    List<Exception> getExceptions();

    @Nonnull
    Version getVersion();

    @Nonnull
    Optional<Repository> getRepository();

{* ../../docs_src/authentication_error_status_code/tutorial001_an_py310.py hl[9:13] *}

/// tip

Notice that the function returns the exception instance, it doesn't raise it. The raising is done in the rest of the internal code.

            try {
                webAuthenticationService.store(entity);
                saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationError(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)),

            log.trace("Socket timeout", ste);
        } catch (final Exception ex) {
            log.warn("Uncaught exception in NameServiceClient", ex);
        } finally {
            tryClose();
        }
    }

    void send(final NameServicePacket request, final NameServicePacket response, int timeout) throws IOException {
        Integer nid = null;

import org.codelibs.fess.annotation.Secured;
import org.codelibs.fess.app.web.base.FessAdminAction;
import org.codelibs.fess.exception.FessSystemException;
import org.codelibs.fess.helper.SystemHelper;
import org.codelibs.fess.util.ComponentUtil;
import org.codelibs.fess.util.RenderDataUtil;
import org.lastaflute.di.exception.IORuntimeException;
import org.lastaflute.web.Execute;
import org.lastaflute.web.response.ActionResponse;

                // Force to no caching state
                entry.updateState(Smb2LeaseState.SMB2_LEASE_NONE);
            }
            releaseLease(key);
        } catch (Exception e) {
            log.error("Error handling lease break for key: " + key, e);
            // On error, ensure we're in safe state
            LeaseEntry entry = leases.get(key);
            if (entry != null) {

        @Test
        @DisplayName("Should handle IOException")
        void testGetSmbTransportIOException() throws UnknownHostException, IOException {
            // Given
            when(transportPool.getSmbTransport(context, TEST_HOST, DEFAULT_PORT, false, false))
                    .thenThrow(new IOException("Connection failed"));

            // When & Then