* @param off
     * @param tot
     * @return
     * @throws IOException
     */
    private int sendFragments(final DcerpcMessage msg, final byte[] out, final NdrBuffer buf) throws IOException {
        int off = 0;
        final int tot = buf.getLength() - 24;
        while (off < tot) {
            int fragSize = tot - off;
            if (24 + fragSize > this.max_xmit) {
                // need fragementation

from fastapi.testclient import TestClient

from .utils import needs_py310


@needs_py310
def test_typing():
    types = {
        list[int]: [1, 2, 3],
        dict[str, list[int]]: {"a": [1, 2, 3], "b": [4, 5, 6]},
        set[int]: [1, 2, 3],  # `set` is converted to `list`
        tuple[int, ...]: [1, 2, 3],  # `tuple` is converted to `list`
    }
    for test_type, expect in types.items():
        app = FastAPI()

pkg net/http, const StatusLoopDetected = 508
pkg net/http, const StatusLoopDetected ideal-int
pkg net/http, const StatusMultiStatus = 207
pkg net/http, const StatusMultiStatus ideal-int
pkg net/http, const StatusNotExtended = 510
pkg net/http, const StatusNotExtended ideal-int
pkg net/http, const StatusPermanentRedirect = 308
pkg net/http, const StatusPermanentRedirect ideal-int
pkg net/http, const StatusProcessing = 102

     * @return the total number of bytes read into the buffer, or -1 if there is no more data
     * @throws IOException if an I/O error occurs
     */
    @Override
    public int read(final byte[] b, final int off, final int len) throws IOException {
        return inputStream.read(b, off, len);
    }

    /**
     * Reads some number of bytes from the input stream and stores them into the buffer array b.
     *

    public static final int WITNESS_REGISTER_NONE = 0x00000000;
    /** Register for IP address change notifications */
    public static final int WITNESS_REGISTER_IP_NOTIFICATION = 0x00000001;

    // Registration state
    private volatile WitnessRegistrationState state;
    private volatile long lastHeartbeat;
    private volatile int heartbeatFailures;
    private int flags;

    /**

                    processor.setTransformer(container.getComponent("fileTransformer"));
                    processor.setSuccessfulHttpCodes(new int[] { 200 });
                    processor.setNotModifiedHttpCodes(new int[] { 304 });
                })//
                .<RegexRule> singleton("fileRule", RegexRule.class, rule -> {
                    rule.setRuleId("fileRule");

     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#writeBytesWireFormat(byte[], int)
     */
    @Override
    protected int writeBytesWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;
        SMBUtil.writeInt2(24, dst, dstIndex);
        SMBUtil.writeInt2(this.closeFlags, dst, dstIndex + 2);
        dstIndex += 4;
        dstIndex += 4; // Reserved

    private final int bytes;
    private boolean done;

    private MessageDigestHasher(MessageDigest digest, int bytes) {
      this.digest = digest;
      this.bytes = bytes;
    }

    @Override
    protected void update(byte b) {
      checkNotDone();
      digest.update(b);
    }

    @Override
    protected void update(byte[] b, int off, int len) {
      checkNotDone();

        final int size = docs.size();
        if (size == 0) {
            return docs; // empty
        }
        int fromIndex = startPosition;
        if (fromIndex >= size) {
            fromIndex = size - 1;
        }
        int toIndex = startPosition + pageSize;
        if (toIndex >= size) {

        final CrawlerWebServer server = new CrawlerWebServer(7070);
        server.start();

        final String url = "http://localhost:7070/";
        try {
            final int maxCount = 50;
            final int numOfThread = 10;

            final File file = File.createTempFile("crawler-", "");
            file.delete();
            file.mkdirs();
            file.deleteOnExit();