}

// currentPathUpdater provides a lightweight update function for keeping track of
// current objects for each disk.
// Returns a function that can be used to update the current object
// and a function to call to when processing finished.
func (p *scannerMetrics) currentPathUpdater(disk, initial string) (update func(path string), done func()) {
	initialPtr := unsafe.Pointer(&initial)
	tracker := &currentPathTracker{

    }

    @Test
    @DisplayName("Test NotifyResponse consistency across multiple calls")
    void testNotifyResponseConsistency() {
        List<FileNotifyInformation> notifications = Arrays.asList(mockNotifyInfo1, mockNotifyInfo2);
        MockNotifyResponse response = new MockNotifyResponse(notifications);

        // Call getNotifyInformation multiple times

    public static class NetrDfsEnumEx extends DcerpcMessage {

        @Override
        public int getOpnum() {
            return 0x15;
        }

        /**
         * Return value from the RPC call
         */
        public int retval;
        /**
         * DFS name to enumerate
         */
        public String dfs_name;
        /**
         * Information level for enumeration
         */

 * try-with-resources. To get the equivalent of that, you must wrap the above code in <i>another</i>
 * try block in order to catch any exception that may be thrown (including from the call to {@code
 * close()}).
 *
 * <p>This pattern ensures the following:
 *
 * <ul>
 *   <li>Each {@code Closeable} resource that is successfully registered will be closed later.

 * iterators that don't support {@code remove()}. Otherwise, all optional operations are supported.
 * Null row keys, columns keys, and values are not supported.
 *
 * <p>Lookups by row key are often faster than lookups by column key, because the data is stored in
 * a {@code Map<R, Map<C, V>>}. A method call like {@code column(columnKey).get(rowKey)} still runs

        auth.close(); // idempotent

        // All operations should throw IllegalStateException
        assertThrows(IllegalStateException.class, () -> auth.getPassword());
        assertThrows(IllegalStateException.class, () -> auth.getPasswordAsCharArray());
    }

    /**
     * Test multiple close() calls (idempotency)
     */
    @Test
    @DisplayName("Test close() method is idempotent")

                    }
                }).start();
            }

            latch.await(5, java.util.concurrent.TimeUnit.SECONDS);
            assertEquals(5, successCount.get(), "All concurrent calls should succeed");
        }
    }

            // Set the length field that will be checked by ServerMessageBlock2Request.encode()
            int calculatedLength = testEncodedLength;
            setLength(calculatedLength);

            // Now call the ServerMessageBlock2Request's encode which will do the validation
            int exp = size();
            int actual = getLength();
            if (exp != actual) {

        assertTrue(testConverter.isInitialized());
    }

    @Test
    public void testInitMultipleTimes() throws IOException {
        // Test multiple initialization calls
        converter.init();
        assertTrue(testConverter.isInitialized());

        // Call init again
        converter.init();
        assertTrue(testConverter.isInitialized());
        assertEquals(2, testConverter.getInitCount());
    }

    @Test

        // Use spy to avoid actual SMB operations
        NetworkExplorer spyExplorer = spy(networkExplorer);
        doNothing().when(spyExplorer).doFile(any(), any(), any());

        // Call the method
        spyExplorer.doFile(request, response, smbFile);

        // Verify the method was called
        verify(spyExplorer).doFile(eq(request), eq(response), eq(smbFile));
    }

    /**