verify(smbFile, times(1)).length();

        // positive size -> accept
        reset(smbFile);
        when(smbFile.length()).thenReturn(42L);
        assertTrue(filter.accept(smbFile), "Positive size should be accepted");
        verify(smbFile, times(1)).length();
        verifyNoMoreInteractions(smbFile);
    }

    @Test

            // Accept files in /share/folder/ that are text files
            return path.equals("/share/folder/") && name != null && name.endsWith(".txt");
        };

        // Act & Assert: test with different file names
        assertTrue(filter.accept(mockDir, "document.txt"), "Should accept .txt files in the correct path");
        assertFalse(filter.accept(mockDir, "image.png"), "Should reject non-.txt files");

        // Filter accepts names starting with "keep"
        when(filter.accept(any())).thenAnswer(inv -> {
            SmbResource res = inv.getArgument(0);
            return res.getName().startsWith("keep");
        });

        ShareEnumIterator it = new ShareEnumIterator(parent, entries.iterator(), filter);

        // Returns only accepted resources
        assertTrue(it.hasNext());

   * empty list of cookies for the network request.
   *
   * Simple implementations will return the accepted cookies that have not yet expired and that
   * [match][Cookie.matches] [url].
   */
  fun loadForRequest(url: HttpUrl): List<Cookie>

  companion object {
    /** A cookie jar that never accepts any cookies. */
    @JvmField
    val NO_COOKIES: CookieJar = NoCookies()

    private class NoCookies : CookieJar {

        // First call: reject, Second call: accept
        when(filter.accept(any(SmbResource.class))).thenReturn(false, true);

        NetServerFileEntryAdapterIterator itr = new NetServerFileEntryAdapterIterator(parent, delegate, filter);

        // Act
        assertTrue(itr.hasNext());
        SmbResource r = itr.next();

        // Assert: filter was invoked twice and we got the accepted one

        // When the accept method is called
        boolean result = dosFileFilter.accept(mockFile);

        // Then the result should be as expected
        if (expectedResult) {
            assertTrue(result, "File should be accepted");
        } else {
            assertFalse(result, "File should not be accepted");
        }
    }

    /**

        assertTrue(filter.accept(file), "Attributes match should be accepted");
        verify(file, times(1)).getAttributes();
    }

    @Test
    public void testAcceptReturnsFalseWhenAttributesDoNotMatch() throws Exception {
        SmbFile file = mock(SmbFile.class);
        when(file.getAttributes()).thenReturn(SmbFile.ATTR_HIDDEN);
        assertFalse(filter.accept(file), "Attributes not matching should be rejected");

 */
public class SmbFileFilterTest {

    /**
     * A minimal implementation that accepts every {@link SmbFile}.
     */
    private final SmbFileFilter ALWAYSACTIVE = new SmbFileFilter() {
        @Override
        public boolean accept(SmbFile file) throws SmbException {
            // Never inspect the file – simply accept.
            return true;
        }
    };

    /**

 * <p>
 * The class under test is a simple wrapper around the base class that
 * sets internal fields in its constructor.
 * These tests verify that the constructor accepts various parameters
 * without throwing exceptions.
 */
@ExtendWith(MockitoExtension.class)
class MsrpcSamrConnect2Test {

    // Helper method to create a minimal SamrPolicyHandle instance.

[many libraries][works_with_okhttp] that sit on top or hook in via existing APIs. If you build
something that integrates with OkHttp, tell us so that we can link it!

Before code can be accepted all contributors must complete our
[Individual Contributor License Agreement (CLA)][cla].


Code Contributions
------------------

Get working code on a personal branch with tests passing before you submit a PR:

```
./gradlew clean check
```