* `HEAD`
* `PATCH`
* `TRACE`

In the HTTP protocol, you can communicate to each path using one (or more) of these "methods".

---

When building APIs, you normally use these specific HTTP methods to perform a specific action.

Normally you use:

* `POST`: to create data.
* `GET`: to read data.
* `PUT`: to update data.
* `DELETE`: to delete data.

        SmbException ex = assertThrows(SmbException.class, () -> poolSpy.getChallenge(ctx, address));
        assertTrue(ex.getMessage().contains("Connection failed"));
    }

    @Test
    @DisplayName("Should perform logon to IPC$ share")
    void testLogon() throws Exception {
        // Given: Mock transport, session and tree
        SmbTransportPoolImpl poolSpy = spy(pool);
        when(ctx.getTransportPool()).thenReturn(poolSpy);

All these tasks help maintain the repository.

A round of applause to them. 👏 🙇

## Team

This is the current list of team members. 😎

They have different levels of involvement and permissions, they can perform [repository management tasks](./management-tasks.md){.internal-link target=_blank} and together we  [manage the FastAPI repository](./management.md){.internal-link target=_blank}.

<div class="user-list user-list-center">

Here are the general instructions for the tasks you can perform.

Thanks a lot for your help. 🙇

## Be Nice

First of all, be nice. 😊

You probably are super nice if you were added to the team, but it's worth mentioning it. 🤓

 *       </ul>
 *   </li>
 * </ul>
 *
 * <p>Fields:
 * <ul>
 *   <li>{@link #client}: The client used to perform analysis.</li>
 *   <li>{@link #settings}: The settings for suggestions.</li>
 *   <li>{@link #analyzerSettings}: The settings for the analyzer.</li>

 * on single thread, keeping the listener logic simple. This listener also blocks on last transfer event to allow
 * output to perform possible cleanup. It spawns a daemon thread to consume queued events that may fall in even
 * concurrently.
 *
 * @since 4.0.0
 */

    }

    /**
     * Test name persistence across operations
     */
    public void test_namePersistence() {
        testTransformer.setName("persistentName");

        // Perform multiple transforms
        for (int i = 0; i < 10; i++) {
            ResponseData responseData = new ResponseData();
            ResultData resultData = testTransformer.transform(responseData);

        resourceManager.registerResource(resource);

        assertFalse(resource.isClosed());

        // Wait for automatic cleanup to kick in
        Thread.sleep(300);

        // Perform cleanup
        resourceManager.performCleanup();

        // Old resource should be auto-closed
        assertTrue(resource.isClosed());
    }

    @Test
    @DisplayName("Test resource statistics")

    void verifyInteractionOrder() throws Exception {
        // Arrange: stub simple returns
        when(handle.hasCapability(anyInt())).thenReturn(true);

        // Act: perform a series of calls to verify order
        handle.ensureDFSResolved();
        handle.hasCapability(7);
        handle.release();

        // Assert: verify they happened in order

JWT might be used for other things apart from identifying a user and allowing them to perform operations directly on your API.

For example, you could identify a "car" or a "blog post".

Then you could add permissions about that entity, like "drive" (for the car) or "edit" (for the blog).