}

    /**
     * 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 {

        return obj instanceof UniAddress && addr.hashCode() == obj.hashCode();
    }
    */

    /**
     * Guess first called name to try for session establishment. This
     * method is used exclusively by the <code>jcifs.smb1.smb1</code> package.
     *
     * @return the first called name to try
     */

    public String firstCalledName() {
        if (addr instanceof NbtAddress) {

     */
    public ProtwordsCreator() {
        super("protwords.*\\.txt");
    }

    /**
     * Registers this creator with the dictionary manager.
     * This method is called automatically after construction to add this creator to the dictionary manager.
     */
    @PostConstruct
    public void register() {
        if (logger.isInfoEnabled()) {

            }

            // 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

   * 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

{* ../../docs_src/dependencies/tutorial001_02_an_py310.py hl[12,16,21] *}

/// tip

This is just standard Python, it's called a "type alias", it's actually not specific to **FastAPI**.

But because **FastAPI** is based on the Python standards, including `Annotated`, you can use this trick in your code. 😎

///

          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 {

 *
 * <p>{@code ByteSource} provides two kinds of methods:
 *
 * <ul>
 *   <li><b>Methods that return a stream:</b> These methods should return a <i>new</i>, independent
 *       instance each time they are called. The caller is responsible for ensuring that the
 *       returned stream is closed.
 *   <li><b>Convenience methods:</b> These are implementations of common operations that are

   *   the first time in a method that nanoTime() has been invoked, for which the special value 0L
   *   is reserved to mean "uninitialized". If timeout is non-positive, then nanoTime need never be
   *   called.
   * - Keep behavior of fair and non-fair instances consistent.
   */

  /**
   * A boolean condition for which a thread may wait. A {@code Guard} is associated with a single