* specified through this <code>jcifs.properties</code> system property.
     *
     * @return a global context, initialized on first call
     */
    public static synchronized final SingletonContext getInstance() {
        if (INSTANCE == null) {
            try {
                log.debug("Initializing singleton context");
                init(null);

        int written = pipe.writeSetupWireFormat(dst, 0);

        assertEquals(4, written, "Setup should write 4 bytes");
        assertEquals(SmbComTransaction.TRANS_WAIT_NAMED_PIPE, dst[0], "First byte should be subCommand");
        assertEquals(0, dst[1], "Second byte should be 0");
        assertEquals(0, dst[2], "Third byte should be 0 (no FID)");
        assertEquals(0, dst[3], "Fourth byte should be 0 (no FID)");

        assertNull(retrieved[0]);
    }

    public void test_multipleOperationsOnSameKey() {
        // Test multiple operations on the same key
        ExtractData data = new ExtractData();

        // First operation
        data.putValue("key", "value1");
        assertEquals("value1", data.getValues("key")[0]);

        // Second operation (overwrite)
        data.putValue("key", "value2");

    private String playerLoc;

    /**
     * The duration of the video in seconds.
     * Value must be from 1 to 28800 (8 hours).
     */
    private String duration;

    /**
     * The date the video was first published, in W3C format.
     */
    private String publicationDate;

    /**
     * An optional arbitrary string tag describing the video.
     * Maximum 32 characters.
     */
    private String category;

            session.acquire();
        }

        // When - Multiple threads try to release/acquire concurrently
        for (int t = 0; t < threadCount; t++) {
            final boolean shouldRelease = (t < 3); // First 3 threads release, others acquire

            executor.submit(() -> {
                try {
                    startLatch.await();

                    if (shouldRelease) {

    }

    @Test
    @DisplayName("Test multiple update and digest cycles")
    void testMultipleUpdateDigestCycles() {
        SMB1SigningDigest digest = new SMB1SigningDigest(testMacSigningKey);

        // First cycle
        byte[] data1 = new byte[] { 0x01, 0x02, 0x03, 0x04 };
        digest.update(data1, 0, data1.length);
        byte[] result1 = digest.digest();
        assertNotNull(result1);

        // Second cycle

                new String[] { SuggestConstants.DEFAULT_ROLE }, null, SuggestItem.Kind.DOCUMENT);

        // First write
        SuggestWriterResult result1 =
                writer.write(runner.client(), suggester.settings(), suggester.getIndex(), new SuggestItem[] { item }, false);
        assertNotNull(result1);

 *   <li>Dynamic passwords provided through extraction parameters</li>
 * </ul>
 *
 * <p>Passwords are matched against URLs or resource names using regular expression patterns.
 * The extractor first tries to match against the URL, then falls back to the resource name if available.
 *
 * @author shinsuke
 */
public abstract class PasswordBasedExtractor extends AbstractExtractor {

        // Given
        when(negotiationRequest.isSigningEnforced()).thenReturn(true).thenReturn(false).thenReturn(true);

        // When & Then
        assertTrue(negotiationRequest.isSigningEnforced(), "First call should return true");
        assertFalse(negotiationRequest.isSigningEnforced(), "Second call should return false");
        assertTrue(negotiationRequest.isSigningEnforced(), "Third call should return true");

        byte[] bufferData = buf.getBuffer();
        assertEquals((byte) 0xCD, bufferData[startIndex + alignmentBytes], "Least significant byte should be first");
        assertEquals((byte) 0x00, bufferData[startIndex + alignmentBytes + 1], "Most significant byte should be second");
    }

    /**
     * When given a buffer with sufficient length, decode performs