}

    @Test
    @DisplayName("getTreeId(): no tree returns -1")
    void getTreeId_noTree_returnsMinusOne() {
        // Arrange
        CIFSContext ctx = mock(CIFSContext.class);
        SmbTreeConnectionTrace trace = new SmbTreeConnectionTrace(ctx);

        // Act & Assert
        assertEquals(-1L, trace.getTreeId());
    }

    @Test

        // Test equal trees (same share and service)
        assertEquals(tree1, tree2);

        // Test non-equal trees (different share)
        assertNotEquals(tree1, tree3);

        // Test non-equal trees (different service)
        assertNotEquals(tree1, tree4);

        // Test with different object type
        assertNotEquals(tree1, new Object());

import mockwebserver3.MockResponse;
import mockwebserver3.MockWebServer;
import okhttp3.Headers;
import org.junit.Test;

import java.io.IOException;

/**
 * Unit test for simple App.
 */
public class AppTest {
  private final MockWebServer mockWebServer = new MockWebServer();

  @Test
  public void testApp() throws IOException {
    mockWebServer.enqueue(new MockResponse(200, Headers.of(), "Hello, Maven!"));

import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.junit.Assert.assertThat;

import org.junit.Test;

/**
 * @author koichik
 *
 */
public class SingleValueIteratorTest {

    /**
     *
     */
    @Test
    public void test() {
        final SingleValueIterator<String> it = new SingleValueIterator<String>("Foo");
        assertThat(it.hasNext(), is(true));

import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

import jcifs.internal.SMBProtocolDecodingException;

/**
 * Test class for CreateContextResponse interface functionality
 */
@DisplayName("CreateContextResponse Tests")
class CreateContextResponseTest {

    /**

    listener.forbidLock(dispatcher)
  }

  @Test
  fun maxRequestsZero() {
    assertFailsWith<IllegalArgumentException> {
      dispatcher.maxRequests = 0
    }
  }

  @Test
  fun maxPerHostZero() {
    assertFailsWith<IllegalArgumentException> {
      dispatcher.maxRequestsPerHost = 0
    }
  }

  @Test
  fun enqueuedJobsRunImmediately() {

        assertTrue(resp instanceof ServerMessageBlock2);
    }

    @Test
    @DisplayName("Should return correct OVERHEAD constant value")
    void testOverheadConstant() {
        // Then
        assertEquals(Smb2Constants.SMB2_HEADER_LENGTH + 16, Smb2ReadResponse.OVERHEAD);
    }

    @Test
    @DisplayName("Should initially have zero data length")
    void testInitialDataLength() {
        // Then

    super(threadName);
    this.lockLikeObject = checkNotNull(lockLikeObject);
    start();
  }

  // Thread.stop() is okay because all threads started by a test are dying at the end of the test,
  // so there is no object state put at risk by stopping the threads abruptly. In some cases a test
  // may put a thread into an uninterruptible operation intentionally, so there is no other way to
  // clean up these threads.
  @SuppressWarnings("deprecation")

import org.eclipse.aether.repository.LocalRepository;
import org.eclipse.aether.util.version.GenericVersionScheme;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import static org.codehaus.plexus.testing.PlexusExtension.getBasedir;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;

        assertFalse(transport.isSMB2());
    }

    @Test
    @DisplayName("Digest setter/getter roundtrip")
    void digestRoundtrip() {
        SMBSigningDigest dg = mock(SMBSigningDigest.class);
        transport.setDigest(dg);
        assertSame(dg, transport.getDigest());
    }

    @Test
    @DisplayName("Context accessor returns constructor-provided context")