void testDeleteDirectory() throws SmbException, CIFSException {
            // Arrange
            // Mock that it exists and is a directory
            doReturn(true).when(smbFile).exists();
            doReturn(true).when(smbFile).isDirectory();

            // Mock listFiles to return empty array (directory is empty)
            doReturn(new SmbFile[0]).when(smbFile).listFiles();

import org.apache.maven.settings.Server;
import org.eclipse.aether.RepositorySystemSession;

/**
 * @since 3.0-alpha
 * @deprecated Use {@link MavenRepositorySystem} if needed, or maven-resolver directly, until maven 4.x api is out
 */
@Deprecated
public interface RepositorySystem {
    String DEFAULT_LOCAL_REPO_ID = MavenRepositorySystem.DEFAULT_LOCAL_REPO_ID;

    @SuppressWarnings("checkstyle:constantname")

If you are experiencing or witnessing conflict, we ask you to use the following escalation strategy to address the conflict:

1.  Address the perceived conflict directly with those involved, preferably in a
    real-time medium.
2.  If this fails, get a third party (e.g. a mutual friend, and/or someone with
    background on the issue, but not involved in the conflict) to intercede.

        }
    }

    public void test_processDBFluteSystem_unlocksAndLocks() {
        // This test verifies that the DBFluteSystem is properly unlocked and locked
        // during the process, though we can't directly test the lock state

        // When
        try {
            curtainBeforeHook.processDBFluteSystem();

            // Then - if we get here without exception, the unlock/lock worked

import org.junit.Ignore;

/**
 * Superclass for all {@code Multimap} testers.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@Ignore("test runners must not instantiate and run this directly, only via suites we build")
// @Ignore affects the Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
@SuppressWarnings("JUnit4ClassUsedInJUnit3")
@NullMarked
public abstract class AbstractMultimapTester<

///

## Embed a single body parameter { #embed-a-single-body-parameter }

Let's say you only have a single `item` body parameter from a Pydantic model `Item`.

By default, **FastAPI** will then expect its body directly.

But if you want it to expect a JSON with a key `item` and inside of it the model contents, as it does when you declare extra body parameters, you can use the special `Body` parameter `embed`:

```Python

            System.setErr(new PrintStream(errContent));

            String[] args = { "--help" };
            // Note: main calls System.exit, so we can't test it directly
            // Instead, we test the parsing logic separately

            System.setErr(originalErr);
        } catch (Exception e) {
            System.setErr(originalErr);
        }
    }

    }

    public void test_clearCache() {
        // Test that clearCache doesn't throw exception
        popularWordHelper.clearCache();

        // Verify cache is cleared (we can't directly test this without accessing the cache)
        // But we can test that it doesn't throw exceptions
        assertTrue(true);
    }

    public void test_init_configuration() {

import java.util.Iterator;
import org.junit.Ignore;

/**
 * Tests for {@code Multiset.entrySet}.
 *
 * @author Jared Levy
 */
@GwtCompatible
@Ignore("test runners must not instantiate and run this directly, only via suites we build")
// @Ignore affects the Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
@SuppressWarnings("JUnit4ClassUsedInJUnit3")

        assertNotNull(tree1);
        assertNotNull(tree2);

        // When - Release session to trigger cleanup
        session.release();

        // Then - Trees should be cleared (we can't directly verify as it's internal,
        // but the cleanup code with synchronized block ensures it happens atomically)
        // The important part is that no exception occurs and the operation is atomic
    }

    /**