}

      connectionPool.evictAll()
      assertEquals(0, connectionPool.connectionCount()) {
        "Still ${connectionPool.connectionCount()} connections open"
      }
    }
  }

  private fun ensureAllTaskQueuesIdle() {
    val entryTime = System.nanoTime()

    for (queue in TaskRunner.INSTANCE.activeQueues()) {

)

func TestGolden(t *testing.T) {
	if *flagCheck {
		// slow, not worth repeating in -check
		t.Skip("skipping with -check set")
	}

	testenv.MustHaveGoBuild(t)

	td, err := os.Open("testdata/src/pkg")
	if err != nil {
		t.Fatal(err)
	}
	fis, err := td.Readdir(0)
	if err != nil {
		t.Fatal(err)
	}
	for _, fi := range fis {
		if !fi.IsDir() {
			continue
		}

        // Act
        int available = stream.available();

        // Assert
        assertEquals(7, available, "Should return available bytes reported by server");

        // Interactions: ensure open, use tree, send IOCTL and close resources
        InOrder inOrder = inOrder(handle, fd, tree);
        inOrder.verify(handle, times(1)).ensureOpen();
        inOrder.verify(fd, times(1)).getTree();

 * are "allowed". If all of the desired access bits are not "allowed"
 * the then same process is repeated for inherited ACEs.
 * <p>
 * For example, if user <code>WNET\alice</code> tries to open a file
 * with desired access bits <code>0x00000003</code> (<code>FILE_READ_DATA |
 * FILE_WRITE_DATA</code>) and the target file has the following security
 * descriptor ACEs:
 * <pre>

                                                    <td>
                                                        <i class="fa fa-folder-open" aria-hidden="true" style="color:#F7C502;">
                                                            ${f:h(data.name)}
                                                    </td>

- **MS-SMB2 Section 2.2.13.2.5**: SMB2_CREATE_DURABLE_HANDLE_RECONNECT
- **MS-SMB2 Section 2.2.13.2.12**: SMB2_CREATE_REQUEST_LEASE_V2
- **MS-SMB2 Section 3.2.1.4**: Durable Open Scavenger Timer

## 3. Handle Types and Capabilities

### 3.1 Handle Types
```java
public enum HandleType {
    NONE(0),                    // No durability

1. Fork repo
2. Create feature branch (`feature/amazing-feature`)
3. Make focused commits
4. Add tests
5. Format code (`mvn formatter:format && mvn license:format`)
6. Run tests (`mvn test`)
7. Open Pull Request

---

## Common Development Tasks

### Adding a Protocol Client

1. **Implement `CrawlerClient`**:
```java
public class MyClient extends AbstractCrawlerClient {
    @Override

                final ExtractData extractData = extractor.getText(in, params);
                return extractData.getContent();
            } catch (final IOException e) {
                throw new ExtractException("Could not open " + outputFile.getAbsolutePath(), e);
            }
        }
        try {
            return new String(FileUtil.readBytes(outputFile), outputEncoding);
        } catch (final UnsupportedEncodingException e) {

    }

    @Test
    void testOpenConnection_UnknownProtocol_ThrowsIOException() {
        // This test verifies that attempting to open a connection for an unsupported protocol
        // results in an IOException, as no default handler should be found.
        assertThrows(IOException.class, () -> {

	if args.QueueDir != "" {
		queueDir := filepath.Join(args.QueueDir, storePrefix+"-redis-"+id)
		queueStore = store.NewQueueStore[event.Event](queueDir, args.QueueLimit, event.StoreExtension)
		if err := queueStore.Open(); err != nil {
			return nil, fmt.Errorf("unable to initialize the queue store of Redis `%s`: %w", id, err)
		}
	}

	pool := &redis.Pool{
		MaxIdle:     3,
		IdleTimeout: 2 * 60 * time.Second,