// Verify that the policyHandle passed to the constructor is the one used
        // This is implicitly tested by the object being constructed without errors.
        // If LsaPolicyHandle had methods called by the constructor, we would verify those calls.
    }

import org.jspecify.annotations.NullUnmarked;

/**
 * Unit test for {@link Files}.
 *
 * <p>Some methods are tested in separate files:
 *
 * <ul>
 *   <li>{@link Files#fileTraverser()} is tested in {@link FilesFileTraverserTest}.
 *   <li>{@link Files#createTempDir()} is tested in {@link FilesCreateTempDirTest}.
 * </ul>
 *
 * @author Chris Nokleberg
 */

import java.util.Collection;
import java.util.List;
import org.jspecify.annotations.NullMarked;

/**
 * Creates collections containing unhashable sample elements, to be tested.
 *
 * @author Regina O'Dell
 */
@GwtCompatible
@NullMarked
public abstract class TestUnhashableCollectionGenerator<T extends Collection<UnhashableObject>>
    implements TestCollectionGenerator<UnhashableObject> {

 *       have, of returning a new, independent iterator
 * </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

                if (fileId != null) {
                    capturedFileId[0] = fileId[0];
                }
            }
        };

        // When
        byte[] testId = new byte[] { 42 };
        anonymousImpl.setFileId(testId);

        // Then
        assertEquals(42, capturedFileId[0], "Anonymous implementation should work correctly");
    }

    @Test

      "Reusing an existing edge to connect different nodes succeeded";

  /** Creates and returns an instance of the graph to be tested. */
  abstract Network<Integer, String> createGraph();

  /**
   * A proxy method that adds the node {@code n} to the graph being tested. In case of Immutable
   * graph implementations, this method should replace {@link #network} with a new graph that
   * includes this node.
   */

import org.mockito.quality.Strictness;

/**
 * Tests for SmbTreeHandle interface.
 * This test class uses Mockito to create a mock implementation of the SmbTreeHandle interface.
 * Each method of the interface is tested to ensure it behaves as expected.
 */
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class SmbTreeHandleTest {

    @Mock
    private SmbTreeHandle smbTreeHandle;

 *       have, of returning a new, independent iterator
 * </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

    /*
     * We'll give ourselves a pass on testing all the possible ways of breaking the constraint,
     * because we know that newClassMap() is implemented using ConstrainedMap which is itself
     * well-tested. A purist would object to this, but what can I say, we're dirty cheaters.
     */
    map.put(Integer.class, new Integer(5));
    assertThrows(ClassCastException.class, () -> map.put(Double.class, new Long(42)));

It is also built to work as a future reference so you can come back and see exactly what you need.

## Run the code { #run-the-code }

All the code blocks can be copied and used directly (they are actually tested Python files).

To run any of the examples, copy the code to a file `main.py`, and start `fastapi dev` with:

<div class="termy">

```console