}

    // Test with large datasets
    @Test
    void testResolveSids_LargeArray() throws CIFSException {
        SID[] largeSidArray = new SID[1000];
        for (int i = 0; i < 1000; i++) {
            largeSidArray[i] = mock(SID.class);
        }

        doNothing().when(sidResolver).resolveSids(any(CIFSContext.class), anyString(), any(SID[].class));

        validateInputStream(in);

        final MimeTypeHelper mimeTypeHelper = getMimeTypeHelper();
        final ExtractorFactory extractorFactory = getExtractorFactory();
        final StringBuilder buf = new StringBuilder(1000);
        int processedEntries = 0;
        int failedEntries = 0;

        try (final ArchiveInputStream ais =

     * Default constructor.
     */
    public IntervalControlHelper() {
        // Default constructor
    }

    /** Wait time in milliseconds when crawler is not running */
    protected long crawlerWaitMillis = 10000;

    /** List of interval rules for controlling crawler timing */
    protected List<IntervalRule> ruleList = new ArrayList<>();

    /**
     * Checks the crawler status and waits if the crawler is not running.

class SmbUnsupportedOperationExceptionTest {

    // Provides a variety of messages including edge cases
    static Stream<String> messages() {
        return Stream.of("custom message", "", " ", "αβγ", "x".repeat(1000), null);
    }

    @Test
    @DisplayName("Default constructor sets the expected message and no cause")
    void defaultConstructor_setsExpectedMessage_andNoCause() {
        // Arrange & Act

		{"bytes=1-", false},

		{"bytes=0-9", false},
		{"bytes=1-10", false},
		{"bytes=1-1", false},
		{"bytes=2-5", false},

		{"bytes=-5", false},
		{"bytes=-1", false},
		{"bytes=-1000", false},
		{"bytes=", true},
		{"bytes= ", true},
		{"byte=", true},
		{"bytes=A-B", true},
		{"bytes=1-B", true},
		{"bytes=B-1", true},
		{"bytes=-1-1", true},
	}

    // Polling and backoff constants (in ms)
    private static final long MAX_POLL_INTERVAL = 5000; // Normal polling: max 5 seconds
    private static final long MAX_ERROR_BACKOFF = 30000; // Error polling: max 30 seconds
    private static final long BASE_POLL_INTERVAL = 1000;
    private static final long BASE_ERROR_DELAY = 1000;
    private static final int MAX_FAILURE_LIMIT = 5; // Limit failures for backoff calculation

     * @return A text.
     */
    protected String getTextInternal(final InputStream in, final MimeTypeHelper mimeTypeHelper, final ExtractorFactory extractorFactory) {
        final StringBuilder buf = new StringBuilder(1000);
        int processedEntries = 0;
        int failedEntries = 0;

        try (final ArchiveInputStream ais = archiveStreamFactory.createArchiveInputStream("tar", in)) {
            TarArchiveEntry entry = null;

        System.out.println(f.getName());
    }
}
```

## Configuration

### Basic Configuration Properties

```properties
# Connection settings
jcifs.smb.client.connTimeout=35000
jcifs.smb.client.soTimeout=180000
jcifs.smb.client.responseTimeout=30000

# Authentication
jcifs.smb.client.domain=WORKGROUP
jcifs.smb.client.username=guest
jcifs.smb.client.password=

		atomic.AddInt32(&ps.numSubscribers, -1)
		return fmt.Errorf("the limit of `%d` subscribers is reached", ps.maxSubscribers)
	}
	ps.Lock()
	defer ps.Unlock()
	subChT := make(chan T, 10000)
	sub := &Sub[T]{ch: subChT, types: Mask(mask.Mask()), filter: filter}
	ps.subs = append(ps.subs, sub)

	// We hold a lock, so we are safe to update
	combined := Mask(atomic.LoadUint64(&ps.types))

    public void testLongText() {
        final CachedCipher cipher = new CachedCipher();
        cipher.setKey("mySecretKey");

        final StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            sb.append("Long text for testing. ");
        }
        final String original = sb.toString();
        final String encrypted = cipher.encryptText(original);