@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;

@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

func (m *bucketMeasurement) updateExponentialMovingAverage(endTime time.Time) {
	// Calculate aggregate avg bandwidth and exp window avg
	m.lock.Lock()
	defer func() {
		m.startTime = endTime
		m.lock.Unlock()
	}()

	if m.startTime.IsZero() {
		return
	}

	if endTime.Before(m.startTime) {
		return
	}

	duration := endTime.Sub(m.startTime)

      };

  public void testSchedule() {
    MockExecutor mock = new MockExecutor();
    TestExecutor testExecutor = new TestExecutor(mock);

    Future<?> unused1 = testExecutor.schedule(DO_NOTHING, 10, MINUTES);
    mock.assertLastMethodCalled("scheduleRunnable", 10, MINUTES);

    Future<?> unused2 = testExecutor.schedule(callable(DO_NOTHING), 5, SECONDS);
    mock.assertLastMethodCalled("scheduleCallable", 5, SECONDS);
  }

            }
        }
    }

    /**
     * Test mock implementation of FileInformation interface
     */
    @Test
    @DisplayName("Test FileInformation interface mock implementation")
    void testFileInformationMockImplementation() {
        // Create mock
        FileInformation mockFileInfo = mock(FileInformation.class);

        // Define behavior

### Locks

We have 3 different things that we synchronize on.

#### Http2Connection

This lock guards internal state of each connection. This lock is never held for blocking operations. That means that we acquire the lock, read or write a few fields and release the lock. No I/O and no application-layer callbacks.

#### Http2Stream

    private NetworkExplorer networkExplorer;

    @Mock
    private ServletConfig servletConfig;

    @Mock
    private ServletContext servletContext;

    @Mock
    private HttpServletRequest request;

    @Mock
    private HttpServletResponse response;

    @Mock
    private HttpSession session;

    @Mock
    private SmbFile smbFile;

    @Mock
    private SmbResourceLocator locator;

	c.mu.Lock()
	bucketIdx := c.nextCleanupBucket
	timeToExpire := time.Until(c.buckets[bucketIdx].newestEntry)
	// wait for newest entry to expire before cleanup without holding lock
	if timeToExpire > 0 {
		c.mu.Unlock()
		time.Sleep(timeToExpire)
		c.mu.Lock()
	}
	for _, ent := range c.buckets[bucketIdx].entries {
		c.removeElement(ent)
	}
	c.nextCleanupBucket = (c.nextCleanupBucket + 1) % numBuckets