*
     * @return the servlet context
     */
    protected ServletContext getServletContext() {
        return LaServletContextUtil.getServletContext();
    }

    /**
     * Verifies that the CRUD mode matches the expected mode.
     *
     * @param crudMode the actual CRUD mode
     * @param expectedMode the expected CRUD mode
     * @param errorHook the error hook to call if verification fails

            fail("Thread interrupted");
        }
    }

    @Test
    public void test_genericTypeSafety_withSubclass() {
        // Test that the exception accepts RootAction subclasses
        // This verifies the change from Class<RootAction> to Class<? extends RootAction>
        UserRoleLoginException exception = new UserRoleLoginException(TestAction.class);
        assertNotNull(exception);

 */
@ExtendWith(MockitoExtension.class)
public class SmbTreeHandleInternalTest {

    @Mock
    private SmbTreeHandleInternal handle;

    @Test
    @DisplayName("release(): verifies it is invoked exactly once")
    void release_invokedOnce() throws Exception {
        // Arrange: no setup needed; we verify interaction only

        // Act: call release
        handle.release();

Now, the STS certificate-based authentication happens in 4 steps:

- Client sends HTTP `POST` request over a TLS connection hitting the MinIO TLS STS API.
- MinIO verifies that the client certificate is valid.
- MinIO tries to find a policy that matches the `CN` of the client certificate.
- MinIO returns temp. S3 credentials associated to the found policy.

        assertEquals("Error 3", exception3.getMessage());
    }

    @Test
    public void test_constructorWithThrowableCause_OutOfMemoryError() {
        // Test that constructor accepts Error as cause (verifies Throwable parameter change)
        String message = "SSO login failed due to memory error";
        OutOfMemoryError error = new OutOfMemoryError("Not enough memory for SSO login");

        assertNull(transport.getServerEncryptionKey());
    }

    // Happy path: session retrieval by context
    @Test
    @DisplayName("getSmbSession(ctx) returns a session and verifies argument")
    void getSmbSession_byContext() {
        when(transport.getSmbSession(any(jcifs.CIFSContext.class))).thenReturn(session);
        SmbSession result = transport.getSmbSession(ctx);

    class StrategyOrderingTests {

        @Test
        @DisplayName("should execute strategies in priority order")
        void shouldExecuteStrategiesInPriorityOrder() throws Exception {
            // This test verifies that strategies are executed in the order they are provided
            // The actual priority ordering is handled by dependency injection
            UpgradeContext context = createMockContext();

    private interface LongGetter {
        long apply(FileEntry e);
    }

    // --- Mockito-based interaction tests ---

    @Test
    @DisplayName("Mocked FileEntry returns stubbed values and verifies interactions")
    void mockedEntry_happyPath_and_interactions() {
        // Arrange: stub all methods with representative values
        when(mockEntry.getName()).thenReturn("file.txt");

    int crc = ~0;
    for (byte b : bytes) {
      crc = (crc >>> 8) ^ Crc32cHashFunction.Crc32cHasher.byteTable[(crc ^ b) & 0xFF];
    }
    return ~crc;
  }

  /**
   * Verifies that the crc of an array of byte data matches the expected value.
   *
   * @param expectedCrc the expected crc value.
   * @param data the data to run the checksum on.
   */

### Test MinIO server changes

After your code changes, make sure

- To add test cases for the new code. If you have questions about how to do it, please ask on our [Slack](https://slack.min.io) channel.
- To run `make verifiers`
- To squash your commits into a single commit. `git rebase -i`. It's okay to force update your pull request.
- To run `make test` and `make build` completes.

### Commit changes