* Equivalent to {@code !matchesNoneOf(sequence)}.
   *
   * <p>The default implementation iterates over the sequence, invoking {@link #matches} for each
   * character, until this returns {@code true} or the end is reached.
   *
   * @param sequence the character sequence to examine, possibly empty
   * @return {@code true} if this matcher matches at least one character in the sequence
   * @since 8.0
   */

                    } catch (final SmbException e) {
                        if (e.getNtStatus() != 0xC0000011) {
                            throw e;
                        }
                        log.debug("Reached end of file", e);
                        n = -1;
                    }
                } else {
                    final SmbComReadAndX request = new SmbComReadAndX(th.getConfig(), fh.getFid(), this.fp, r, null);

      Thread.currentThread().interrupt() // Retain interrupted status.
      throw InterruptedIOException()
    }
  }

  /**
   * The Okio timeout watchdog will call [timedOut] if the timeout is reached. In that case we close
   * the stream (asynchronously) which will notify the waiting thread.
   */
  internal inner class StreamTimeout : AsyncTimeout() {
    override fun timedOut() {
      closeLater(ErrorCode.CANCEL)

			}
		}

		// if we have reached the count send at once
		// or we have crossed last second before batch was sent, send at once
		lastBatchProcess = time.Now()

		var retries int
		retryIntvl := h.config.RetryIntvl
		if retryIntvl <= 0 {
			retryIntvl = 3 * time.Second
		}

		maxRetries := h.config.MaxRetry

	retry:
		// If the channel reaches above half capacity

    assertThat(limiter.acquire()).isWithin(EPSILON).of(0.2);
  }

  public void testOneSecondBurst() {
    RateLimiter limiter = RateLimiter.create(5.0, stopwatch);
    stopwatch.sleepMillis(1000); // max capacity reached
    stopwatch.sleepMillis(1000); // this makes no difference
    limiter.acquire(1); // R0.00, since it's the first request

    limiter.acquire(1); // R0.00, from capacity
    limiter.acquire(3); // R0.00, from capacity

    assertThat(limiter.acquire()).isWithin(EPSILON).of(0.2);
  }

  public void testOneSecondBurst() {
    RateLimiter limiter = RateLimiter.create(5.0, stopwatch);
    stopwatch.sleepMillis(1000); // max capacity reached
    stopwatch.sleepMillis(1000); // this makes no difference
    limiter.acquire(1); // R0.00, since it's the first request

    limiter.acquire(1); // R0.00, from capacity
    limiter.acquire(3); // R0.00, from capacity

```java
public enum HandleBreakReason {
    NETWORK_FAILURE,      // Network connection lost
    SESSION_EXPIRED,      // Session timeout
    SERVER_REBOOT,        // Server restart
    HANDLE_EXPIRED,       // Handle timeout reached
    LEASE_BREAK,         // Associated lease broken
    EXPLICIT_CLOSE       // User closed handle
}

public class HandleBreakHandler {
    public void handleBreak(HandleInfo handle, HandleBreakReason reason) {

            if (logger.isDebugEnabled()) {
                logger.debug("[getParentGroup] Maximum group depth {} reached for group {}", maxGroupDepth, id);
            }
            return new Pair<>(StringUtil.EMPTY_STRINGS, StringUtil.EMPTY_STRINGS);
        }
        // Check if cached
        final Pair<String[], String[]> cachedResult = groupCache.getIfPresent(id);
        if (cachedResult != null) {

                // If still at limit, throw exception
                if (this.connections.size() >= maxPoolSize) {
                    throw new IllegalStateException("Connection pool has reached maximum size of " + maxPoolSize
                            + ". Consider increasing pool size or closing idle connections.");
                }
            }
        }

		return 0, 0, nil
	}
	partOffset = offset
	// Seek until object offset maps to a particular part offset.
	for i, part := range fi.Parts {
		partIndex = i
		// Offset is smaller than size we have reached the proper part offset.
		if partOffset < part.Size {
			return partIndex, partOffset, nil
		}
		// Continue to towards the next part.
		partOffset -= part.Size
	}
	internalLogIf(ctx, InvalidRange{})