assertTrue(session.isInUse(), "Session should be in use initially");
        try (SmbSessionImpl autoSession = session) {
            // Session is already in use due to transport acquisition
            assertTrue(autoSession.isInUse(), "Session should be in use");
        }

        // Session should be automatically released
        assertFalse(session.isInUse(), "Session should be released after try-with-resources");
    }

     * another thread or the worker task has cleared the count and set the state.
     *
     * <p>When {@link #executor} is a directExecutor(), the value written to
     * {@code workerRunningState} will be available synchronously, and behaviour will be
     * deterministic.
     */
    @SuppressWarnings("GuardedBy")
    boolean alreadyMarkedQueued = workerRunningState != QUEUING;
    if (alreadyMarkedQueued) {
      return;
    }

The *path operation decorator* receives an optional argument `dependencies`.

It should be a `list` of `Depends()`:

{* ../../docs_src/dependencies/tutorial006_an_py39.py hl[19] *}

These dependencies will be executed/solved the same way as normal dependencies. But their value (if they return any) won't be passed to your *path operation function*.

/// tip

 * </ul>
 *
 * <p>Because of this situation, any public method accepting an iterable should invoke the {@code
 * iterator} method only once, and should be tested using this class. Exceptions to this rule should
 * be clearly documented.
 *
 * <p>Note that although your APIs should be liberal in what they accept, your methods which
 * <i>return</i> iterables should make every attempt to return ones of the robust variety.
 *

      // since the operation would be a no-op, the exception is not required
    }
    expectUnchanged();
  }

  @MapFeature.Require(value = SUPPORTS_REMOVE, absent = ALLOWS_NULL_VALUE_QUERIES)
  public void testRemove_nullValueQueriesUnsupported() {
    try {
      assertFalse(getMap().remove(k3(), null));
    } catch (NullPointerException tolerated) {
      // since the operation would be a no-op, the exception is not required
    }

        return builder()
                .session(requireNonNull(session, "session cannot be null"))
                .artifactCoordinates(requireNonNull(artifactCoordinates, "artifactCoordinates cannot be null"))
                .build();
    }

    @Nonnull
    static VersionResolverRequest build(
            @Nonnull Session session,

        verify(file, times(1)).getAttributes();
    }

    @Test
    public void testAcceptReturnsFalseWhenAttributesDoNotMatch() throws Exception {
        SmbFile file = mock(SmbFile.class);
        when(file.getAttributes()).thenReturn(SmbFile.ATTR_HIDDEN);
        assertFalse(filter.accept(file), "Attributes not matching should be rejected");

        assertNotNull("CrawlingConfigHelper should be registered", ComponentUtil.getComponent("crawlingConfigHelper"));
        assertNotNull("SystemHelper should be registered", ComponentUtil.getSystemHelper());
        assertNotNull("FessConfig should be set", ComponentUtil.getFessConfig());
        assertTrue("Component integration test should be fast", true);
    }

    public void test_basic_functionality() {

        assertNotNull(encryptedStr, "Encrypted string should not be null");
        assertFalse(encryptedStr.contains("TestPassword456"), "Plaintext should not be visible in encrypted string");

        // Should be valid base64
        assertTrue(encryptedStr.matches("^[A-Za-z0-9+/]*={0,2}$"), "Should be valid Base64 format");

        // Decrypt from string

        assertEquals("Maximum version should be SMB 3.1.1", DialectVersion.SMB311, config.getMaximumVersion());
    }

    /**
     * Test that SMB1 is disabled by default
     */
    @Test
    public void testSMB1Disabled() throws CIFSException {
        BaseConfiguration config = new BaseConfiguration(true);

        // SMB1 versions should not be allowed