void testConstructorUsesConfiguration() {
        // Then
        assertSame(mockConfig, context.getConfig(), "Should use provided configuration");
        verify(mockConfig).getDefaultUsername();
        verify(mockConfig).getDefaultPassword();
        verify(mockConfig).getDefaultDomain();
    }

    @Test
    @DisplayName("Constructor should handle credentials from configuration")

        response = new TransTransactNamedPipeResponse(mockConfig, outputBuffer);
    }

    @Test
    void testConstructor() {
        // Verify that the response is created with correct configuration and buffer
        assertNotNull(response);

        // Use reflection to verify the outputBuffer is set correctly
        try {
            Field outputBufferField = TransTransactNamedPipeResponse.class.getDeclaredField("outputBuffer");

        Element pluginManagementElement = DomUtils.insertNewElement("pluginManagement", buildElement);
        assertNotNull(pluginManagementElement, "Should create pluginManagement element");

        // Verify it was added to the document
        String xmlOutput = DomUtils.toXml(doc);
        assertTrue(xmlOutput.contains("<pluginManagement>"), "Should contain pluginManagement element");
    }

    @Test

        multimap.putAll("bar", asList(5, 6));
        multimap.putAll("foo", asList(7, 8));
        return multimap.get("foo").iterator();
      }

      @Override
      protected void verify(List<Integer> elements) {
        assertEquals(new HashSet<>(elements), multimap.get("foo"));
      }
    }.test();
  }

  @GwtIncompatible // unreasonably slow
  public void testEntriesIteration() {

import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.io.IOException;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

import org.junit.jupiter.api.BeforeEach;

            // Read the buffer
            int bytesRead = notification.readBytesWireFormat(buffer, 0);

            // Verify the bytes read
            assertEquals(24, bytesRead);

            // Verify the fields were set correctly using reflection
            Field oplockLevelField = Smb2OplockBreakNotification.class.getDeclaredField("oplockLevel");

        assertTrue(region.hasAccess(RdmaAccess.LOCAL_READ), "Should have local read access");
        assertTrue(region.hasAccess(RdmaAccess.REMOTE_READ), "Should have remote read access");

        // Verify provider was called
        verify(mockProvider, atLeastOnce()).registerMemory(any(ByteBuffer.class), any());
    }

    @Test
    public void testReleaseSendRegion() throws Exception {

 * limitations under the License.
 */

package com.google.common.util.concurrent;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import com.google.common.util.concurrent.UncaughtExceptionHandlers.Exiter;

import jcifs.internal.smb2.ServerMessageBlock2Request;
import jcifs.smb.SmbSessionInternal;
import jcifs.smb.SmbTransportInternal;

/**
 * Unit tests for SMB3 Multi-Channel functionality
 *
 * These tests verify the multi-channel implementation without requiring a real SMB server.
 */
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class MultiChannelIntegrationTest {

    @Mock

     *
     * @see jcifs.internal.SMBSigningDigest#verify(byte[], int, int, int, jcifs.internal.CommonServerMessageBlock)
     */
    @Override
    public boolean verify(final byte[] data, final int offset, final int length, final int extraPad, final CommonServerMessageBlock msg) {
        // Validate input parameters
        if (data == null) {
            log.error("Data buffer is null in verify");
            return false;
        }