@BeforeEach
    void setUp() throws IOException {
        // Mock the CIFSContext and its dependencies
        mockContext = mock(CIFSContext.class);
        mockConfig = mock(Configuration.class);
        mockCredentials = mock(Credentials.class);
        mockTransportPool = mock(SmbTransportPool.class);

        // Set up mock behaviors
        when(mockContext.getConfig()).thenReturn(mockConfig);

    private TestNtlmServlet ntlmServlet;

    @Mock
    private ServletConfig servletConfig;

    @Mock
    private HttpServletRequest request;

    @Mock
    private HttpServletResponse response;

    @Mock
    private HttpSession session;

    @Mock
    private CIFSContext cifsContext;

    @Mock
    private Configuration configuration;

    @Mock
    private jcifs.SmbTransportPool transportPool;

@ExtendWith(MockitoExtension.class)
class SmbFileOutputStreamTest {

    @Mock
    private SmbFile mockFile;

    @Mock
    private SmbTreeHandleImpl mockTreeHandle;

    @Mock
    private SmbFileHandleImpl mockFileHandle;

    @Mock
    private Configuration mockConfig;

    @Mock
    private Smb2WriteResponse mockWriteResponse;

    private SmbFileOutputStream outputStream;

            lock.readLock().unlock();
        }
    }

    /**
     * Get handle information by path
     * @param path the file path
     * @return the handle info or null if not found
     */
    public HandleInfo getHandleByPath(String path) {
        lock.readLock().lock();
        try {
            return handles.get(path);
        } finally {
            lock.readLock().unlock();
        }
    }

@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class SmbResourceLocatorImplTest {

    @Mock
    private CIFSContext ctx;
    @Mock
    private Configuration config;
    @Mock
    private Credentials creds;
    @Mock
    private NameServiceClient nsc;

    // Minimal URLStreamHandler to allow creating smb:// URLs in tests

    @Test
    void testSuccessfulRegistration() throws Exception {
        // Setup mock RPC response
        WitnessRegisterResponse mockResponse = mock(WitnessRegisterResponse.class);
        lenient().when(mockResponse.isSuccess()).thenReturn(true);
        lenient().when(mockResponse.getRegistrationId()).thenReturn("test-reg-123");

        WitnessRpcClient mockRpc = mock(WitnessRpcClient.class);

        }
      };

  private static final Supplier<Lock> LOCK_SUPPLER =
      new Supplier<Lock>() {
        @Override
        public Lock get() {
          return new ReentrantLock();
        }
      };

  private static final Supplier<Lock> FAIR_LOCK_SUPPLER =
      new Supplier<Lock>() {
        @Override
        public Lock get() {
          return new ReentrantLock(true);
        }
      };

        }
      };

  private static final Supplier<Lock> LOCK_SUPPLER =
      new Supplier<Lock>() {
        @Override
        public Lock get() {
          return new ReentrantLock();
        }
      };

  private static final Supplier<Lock> FAIR_LOCK_SUPPLER =
      new Supplier<Lock>() {
        @Override
        public Lock get() {
          return new ReentrantLock(true);
        }
      };

  enum Impl {
    EAGER {
      @Override
      Striped<Lock> get(int stripes) {
        return Striped.lock(stripes);
      }
    },
    LAZY_SMALL {
      @Override
      Striped<Lock> get(int stripes) {
        return new Striped.SmallLazyStriped<>(stripes, LOCK_SUPPLIER);
      }
    },
    LAZY_LARGE {
      @Override
      Striped<Lock> get(int stripes) {

    private CIFSContext mockDelegate;
    private Configuration mockConfiguration;
    private CIFSContextWrapper cifsContextWrapper;

    @BeforeEach
    void setUp() {
        mockDelegate = mock(CIFSContext.class);
        mockConfiguration = mock(Configuration.class);
        when(mockDelegate.getConfig()).thenReturn(mockConfiguration);