"flags should be DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG");
        // Verify that the super constructor was called with the correct handle.
        // This is implicitly tested by the object being created without error and
        // the fields set by the constructor being correct.
    }

        assertEquals(SmbOperationException.ErrorCategory.NETWORK, exception.getErrorCategory());
        assertTrue(exception.isRetryable());
    }

    @Test
    @DisplayName("Should handle retry policy correctly")
    void testRetryPolicy() {
        // Given
        SmbOperationException.RetryPolicy policy = new SmbOperationException.RetryPolicy(3, 1000, 10000, 2.0, true);

        assertFalse(info.isReconnecting());
        assertNull(info.getFile());
    }

    @Test
    public void testHandleInfoExpiration() {
        // Test durable handle expiration
        HandleInfo durableInfo = new HandleInfo("/test/file.txt", testGuid, testFileId, HandleType.DURABLE_V2, 100, // 100ms timeout
                null);

        assertFalse(durableInfo.isExpired());

Now let's go back a bit and understand what is all that.

The `password` "flow" is one of the ways ("flows") defined in OAuth2, to handle security and authentication.

OAuth2 was designed so that the backend or API could be independent of the server that authenticates the user.

But in this case, the same **FastAPI** application will handle the API and the authentication.

So, let's review it from that simplified point of view:

pkg syscall, const EBADMSG Errno #67998
pkg syscall, const EPROTO Errno #67998
pkg unicode/utf16, func RuneLen(int32) int #44940
pkg unique, func Make[$0 comparable]($0) Handle[$0] #62483
pkg unique, method (Handle[$0]) Value() $0 #62483

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import org.jspecify.annotations.NullUnmarked;

/** Simple derived class to verify that we handle generics correctly. */
@GwtCompatible
@NullUnmarked
class Derived extends Base {
  public Derived(String s) {
    super(s);
  }

  @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;

                      ", dtype=", DataType_Name(DataType()),
                      ", type=", FullType().DebugString(), ")");
}

absl::Status AbstractTensorHandle::TensorHandleStatus() const {
  // Tensor handles in current runtime don't carry error info and this method
  // should always return OK status.
  return absl::OkStatus();
}

 * under the License.
 */
package org.apache.maven.repository;

import java.util.List;

import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.settings.Mirror;

/**
 * Handles the selection of mirrors for repositories.
 *
 */
@Deprecated
public interface MirrorSelector {

    /**
     * Determines the mirror for the specified repository.
     *

        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          config: >
            {
              "answered": {
                "delay": 864000,
                "message": "Assuming the original need was handled, this will be automatically closed now. But feel free to add more comments or create new issues or PRs."
              },
              "waiting": {
                "delay": 2628000,

In this case, it requires the scope `me` (it could require more than one scope).

/// note

You don't necessarily need to add different scopes in different places.

We are doing it here to demonstrate how **FastAPI** handles scopes declared at different levels.

///

{* ../../docs_src/security/tutorial005_an_py310.py hl[5,141,172] *}

/// info | Technical Details