@BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        response = new NtTransNotifyChangeResponse(mockConfig);
    }

    @Test
    @DisplayName("Test constructor creates instance with empty notification list")
    void testConstructor() {
        assertNotNull(response);
        assertNotNull(response.getNotifyInformation());
        assertTrue(response.getNotifyInformation().isEmpty());

            @Override
            protected SmbResource adapt(FileEntry e) {
                return mockResource1;
            }
        };

        // Then
        assertNotNull(iterator, "Iterator should be created");
        assertFalse(iterator.hasNext(), "Should not have elements");
    }

    /**
     * Test that the iterator handles null return from next correctly.
     */
    @Test

A subroute on a client must match a subroute on the server. So routes cannot be used for dynamic routing, unlike HTTP.

Handlers should remain backwards compatible. If a breaking API change is required, a new handler ID should be created.

## Setup & Configuration

A **Manager** is used to manage all incoming and outgoing connections to a server.

On startup all remote servers must be specified.

```

## Create a bucket and upload some data

Create a bucket named `functionbucket`
```
mc alias set myminio/ http://localhost:9000 minioadmin minioadmin
mc mb myminio/functionbucket
```

Create a file `testobject` with some test data that will be transformed
```
cat > testobject << EOF

    void testInterfaceCanBeMocked() {
        // Given
        SmbNegotiationRequest mockRequest = mock(SmbNegotiationRequest.class);

        // Then
        assertNotNull(mockRequest, "Mock should be created successfully");
    }

    @Test
    @DisplayName("Test default behavior of mock without stubbing")
    void testDefaultBehaviorOfMock() {
        // Given

	Listeners   []net.Listener
	Managers    []*Manager
	Mux         []*mux.Router
	Hosts       []string
	cleanupOnce sync.Once
	cancel      context.CancelFunc
}

// SetupTestGrid creates a new grid for testing purposes.
// Select the number of hosts to create.
// Call (TestGrid).Cleanup() when done.
func SetupTestGrid(n int) (*TestGrid, error) {
	hosts, listeners, err := getHosts(n)
	if err != nil {
		return nil, err
	}

        checkstyleTask.configure(t -> t.dependsOn(project.getTasks().withType(Checkstyle.class)));

        // Apply the checkstyle plugin to create `checkstyleMain` and `checkstyleTest`. It only
        // creates them if there is main or test code to check and it makes `check` depend
        // on them. We also want `precommit` to depend on `checkstyle`.
        project.getPluginManager().apply("checkstyle");

</div>

And copy the output to the variable `SECRET_KEY` (don't use the one in the example).

Create a variable `ALGORITHM` with the algorithm used to sign the JWT token and set it to `"HS256"`.

Create a variable for the expiration of the token.

Define a Pydantic Model that will be used in the token endpoint for the response.

Create a utility function to generate a new access token.

   * references, which is particularly hard to quantify.
   */

  /** Creates an empty {@code CompactHashMap} instance. */
  public static <K extends @Nullable Object, V extends @Nullable Object>
      CompactHashMap<K, V> create() {
    return new CompactHashMap<>();
  }

  /**
   * Creates a {@code CompactHashMap} instance, with a high enough "initial capacity" that it

@GwtCompatible
@NullMarked
final class ObjectCountLinkedHashMap<K extends @Nullable Object> extends ObjectCountHashMap<K> {
  /** Creates an empty {@code ObjectCountLinkedHashMap} instance. */
  static <K extends @Nullable Object> ObjectCountLinkedHashMap<K> create() {
    return new ObjectCountLinkedHashMap<K>();
  }

  /**
   * Creates a {@code ObjectCountLinkedHashMap} instance, with a high enough "initial capacity" that