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");

 */
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;
        }
    };

    /**

                entry("keep2", SmbConstants.TYPE_SHARE));

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

        when(mockDelegate.next()).thenReturn(mockFileEntry1, mockFileEntry2, mockFileEntry3);

        // Create a mock filter that accepts file1 and file3 but not file2
        when(mockFilter.accept(mockResource1)).thenReturn(true);
        when(mockFilter.accept(mockResource2)).thenReturn(false);
        when(mockFilter.accept(mockResource3)).thenReturn(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.

        assertFalse(itr.hasNext());
    }

    @Test
    @DisplayName("Filter rejects first, accepts second; interactions verified")
    void filterRejectsThenAccepts_nextYieldsAccepted() throws Exception {
        // Arrange: two entries; filter rejects first, accepts second
        setupParentForUrlCreation();
        StubFileEntry skip = new StubFileEntry("SKIPME", SmbConstants.TYPE_SERVER);

}

func (s *sftpLogger) Error(tag xsftp.LogType, err error) {
	switch tag {
	case xsftp.AcceptNetworkError:
		sftpLogOnceIf(context.Background(), err, "accept-limit-sftp")
	case xsftp.AcceptChannelError:
		sftpLogOnceIf(context.Background(), err, "accept-channel-sftp")
	case xsftp.SSHKeyExchangeError:
		sftpLogOnceIf(context.Background(), err, "key-exchange-sftp")
	default:

        // When calling accept
        // Then it should be accepted because the READONLY attribute is present
        assertTrue(dosFileFilter.accept(mockFile));
    }

    /**
     * Tests that the accept method returns false when the file attributes do not
     * contain any of the attributes specified in the filter.

        // Wildcard shouldn't affect accept logic.
        DosFileFilter customFilter = new DosFileFilter("*.txt", SmbFile.ATTR_DIRECTORY);
        SmbFile file = mock(SmbFile.class);
        when(file.getAttributes()).thenReturn(SmbFile.ATTR_DIRECTORY);
        assertTrue(customFilter.accept(file), "Wildcard should be ignored in accept");
    }

    @Test
    public void testAcceptHandlesNullFile() {