This is useful when you want to have optional authentication.

                It is also useful when you want to have authentication that can be
                provided in one of multiple optional ways (for example, in a query
                parameter or in an HTTP Bearer token).
                """
            ),
        ] = True,
    ):
        super().__init__(

    validations:
      required: true

  - type: dropdown
    attributes:
      label: Packages
      description: If this issue is package-specific, then please select the relevant packages.
      multiple: true
      options:
        - com.google.common.annotations
        - com.google.common.base
        - com.google.common.cache
        - com.google.common.collect
        - com.google.common.escape

        assertNull(responseData.getUrl());
        assertEquals(0, responseData.getHttpStatusCode());
    }

    public void test_processMultipleTimes() {
        // Test calling process multiple times
        NullResponseProcessor processor = new NullResponseProcessor();
        ResponseData responseData1 = new ResponseData();
        responseData1.setUrl("https://example.com/page1");

	"syscall"
	"time"

	"github.com/minio/minio/internal/deadlineconn"
)

type acceptResult struct {
	conn net.Conn
	err  error
	lidx int
}

// httpListener - HTTP listener capable of handling multiple server addresses.
type httpListener struct {
	opts        TCPOptions
	listeners   []net.Listener    // underlying TCP listeners.
	acceptCh    chan acceptResult // channel where all TCP listeners write accepted connection.

        // Then
        assertFalse(result, "isSigningEnforced should return false when signing is not enforced");
        verify(negotiationRequest, times(1)).isSigningEnforced();
    }

    @Test
    @DisplayName("Test multiple calls to isSigningEnforced")
    void testMultipleCallsToIsSigningEnforced() {
        // Given
        when(negotiationRequest.isSigningEnforced()).thenReturn(true).thenReturn(false).thenReturn(true);

        // Process multiple elements
        int count = 1;
        while (transaction.hasMoreElements() && count < 10) {
            transaction.nextElement();
            count++;
        }

        assertTrue(count > 1, "Large data should require multiple elements");
    }

    @Test
    @DisplayName("Test transaction name handling")

        assertEquals(0x12345678, ((AvFlags) pair).getFlags(), "Flags value should match");
    }

    /**
     * Test decode with multiple AvPairs
     */
    @Test
    @DisplayName("Decode multiple AvPairs with EOL")
    void testDecodeMultiplePairs() throws CIFSException {
        // Create multiple AvPairs
        byte[] flagData = new byte[4];
        SMBUtil.writeInt4(0xAABBCCDD, flagData, 0);

    }

    // We need to take in multiple lifecycles
    @Test
    public void testCalculationOfBuildPlanWithMultipleExecutionsOfModello() throws Exception {
        File pom = getProject("project-with-multiple-executions");
        MavenSession session = createMavenSession(pom);
        assertEquals(
                "project-with-multiple-executions", session.getCurrentProject().getArtifactId());

    public void test_multipleCloseCallsDoNothing() throws IOException {
        // Test that multiple close() calls are all ignored
        byte[] data = "Test data".getBytes();
        ByteArrayInputStream underlyingStream = new ByteArrayInputStream(data);
        IgnoreCloseInputStream stream = new IgnoreCloseInputStream(underlyingStream);

        // Multiple close calls should all be ignored
        stream.close();
        stream.close();

**FastAPI** is based on **OpenAPI**.

That's what makes it possible to have multiple automatic interactive documentation interfaces, code generation, etc.

OpenAPI has a way to define multiple security "schemes".

By using them, you can take advantage of all these standard-based tools, including these interactive documentation systems.