verify(response).setStatus(HttpServletResponse.SC_UNAUTHORIZED);
    }

    /**
     * Test handling of various path formats
     * This test verifies path parsing without actual network operations
     */
    @Test
    void testPathHandling() throws Exception {
        // Create a test-specific NetworkExplorer that doesn't make network calls

        // Only valid host should be added
        NbtAddress validHost = lmhosts.getByName("VALIDHOST", mockContext);
        assertNotNull(validHost);

        // Invalid entries should not be found or may have incorrect parsing
        // Note: The actual Lmhosts parser may accept "192.168.1" and parse it differently
        // than expected, so we're not asserting null for HOST1
    }

    @Test

     */
    public boolean isNoWaitOnFolder() {
        return noWaitOnFolder;
    }

    /**
     * Sets whether the crawler waits on folder operations.
     * @param noWaitOnFolder true to disable waiting on folder operations.
     */
    public void setNoWaitOnFolder(final boolean noWaitOnFolder) {
        this.noWaitOnFolder = noWaitOnFolder;
    }

    /**
     * Sets the client factory.

        DummyAndXBlock block = new DummyAndXBlock() {
            @Override
            int readHeaderWireFormat(byte[] buffer, int bufferIndex) {
                // Simulate fixed-size header parsing
                return 33;
            }
        };

        byte[] buf = new byte[128];
        // After header at 0..32
        buf[33] = 4; // wordCount
        buf[34] = (byte) 0xFF; // andxCommand

            // Then
            assertEquals(4, bytesRead, "Iteration " + i + " should read 4 bytes");
        }
    }

    @Test
    @DisplayName("Should verify complete response structure parsing")
    void testCompleteResponseParsing() throws SMBProtocolDecodingException {
        // Given - complete SMB2 TREE_DISCONNECT response
        byte[] completeResponse = new byte[] { 0x04, 0x00, // StructureSize = 4

If you are paying for 3 servers but you are using only a little bit of their RAM and CPU, you are probably **wasting money** 💸, and probably **wasting server electric power** 🌎, etc.

In that case, it could be better to have only 2 servers and use a higher percentage of their resources (CPU, memory, disk, network bandwidth, etc).

	}
	h.SetModTime(ts)

	testValidHeader(&h, t)
}

func TestHeaderTooShort(t *testing.T) {
	h := FileHeader{
		Name:   "foo.txt",
		Method: Deflate,
		Extra:  []byte{zip64ExtraID}, // missing size and second half of tag, but Extra is best-effort parsing
	}
	testValidHeader(&h, t)
}

    @SuppressWarnings("unused") // https://errorprone.info/bugpattern/FutureReturnValueIgnored
    Future<?> possiblyIgnoredError = threadPool.submit(new Interrupter(currentThread()));
    try {
      // if waiting works, this should get stuck
      Queues.drain(q, new ArrayList<>(), 1, MAX_VALUE, NANOSECONDS);
      fail();
    } catch (InterruptedException expected) {

                    new SrvCopychunk(10, 11, 12), new SrvCopychunk(13, 14, 15) };

            for (int numChunks = 0; numChunks <= testCases.length; numChunks++) {
                // Create copy with varying number of chunks
                SrvCopychunk[] chunks = Arrays.copyOf(testCases, numChunks);
                SrvCopychunkCopy copy = new SrvCopychunkCopy(sourceKey, chunks);
                byte[] buffer = new byte[500];

    protected static final String CRAWLER_CLIENTS = "crawlerClients";

    /**
     * Cache for client rules mapping client names to their corresponding URL patterns.
     * This cache improves performance by avoiding repeated parsing of client configuration rules.
     * The key is the rule string, and the value is a pair containing the client name and compiled pattern.
     */