// Should alternate between channels
        ChannelInfo first = loadBalancer.selectChannel(mockMessage);
        ChannelInfo second = loadBalancer.selectChannel(mockMessage);

        assertNotNull(first);
        assertNotNull(second);
        // Due to round-robin, should get different channels or same order

        assertTrue("Minimum version should be at least SMB2.0.2", config.getMinimumVersion().atLeast(DialectVersion.SMB202));

        // Verify LM compatibility level is 3 or higher (NTLMv2 only)
        assertTrue("LM compatibility should be 3 or higher for NTLMv2 only", config.getLanManCompatibility() >= 3);
        assertEquals("LM compatibility should default to 3", 3, config.getLanManCompatibility());

            assertEquals(0, aad[i], "Signature bytes should be zero in AAD");
        }

        // Verify nonce matches at position 20
        for (int i = 0; i < 16; i++) {
            assertEquals(testNonce[i], aad[20 + i], "Nonce should match at position " + (20 + i));
        }
    }

    @Test
    @DisplayName("Should create transform header with constructor")

    class GetterMethodsTests {

        @Test
        @DisplayName("getCloseFlags should return initial value of 0")
        void testGetCloseFlags() {
            assertEquals(0, response.getCloseFlags());
        }

        @Test
        @DisplayName("getCreationTime should return initial value of 0")
        void testGetCreationTime() {
            assertEquals(0, response.getCreationTime());

  @MapFeature.Require(SUPPORTS_PUT)
  public void testComputeIfAbsent_supportedAbsent() {
    assertEquals(
        "computeIfAbsent(notPresent, function) should return new value",
        v3(),
        getMap()
            .computeIfAbsent(
                k3(),
                k -> {
                  assertEquals(k3(), k);
                  return v3();

        // Test Unicode configuration is enabled by default
        assertTrue(cfg.isUseUnicode(), "Unicode should be enabled by default");
    }

    @Test
    public void testAsciiConfiguration() throws Exception {
        Configuration asciiCfg = new OffUnicodeConfig();
        assertFalse(asciiCfg.isUseUnicode(), "Unicode should be disabled in ASCII config");
    }

    @Test
    public void testUnicodeEncoding() {

		t.Fatalf("joins NamedPet and Account should not empty:%v", user1)
	}

	// Account should empty
	DB.Delete(&user1.Account)

	var user2 User
	DB.Model(&User{}).Joins("NamedPet").Joins("Account").First(&user2, user.ID)
	if user2.NamedPet == nil || user2.Account.ID != 0 {
		t.Fatalf("joins Account should not empty:%v", user2)
	}

	// NamedPet should empty
	DB.Delete(&user1.NamedPet)

        assertEquals(positiveValue, ndrLongPositive.value, "Constructor should correctly initialize with a positive value.");

        // Test case 2: Negative value
        int negativeValue = -54321;
        NdrLong ndrLongNegative = new NdrLong(negativeValue);
        assertEquals(negativeValue, ndrLongNegative.value, "Constructor should correctly initialize with a negative value.");

        // Test case 3: Zero value

import jcifs.CIFSException;

class NbtExceptionTest {

    /**
     * Test the constructor of NbtException.
     * It should correctly set errorClass and errorCode, and the message should be derived from getErrorString.
     */
    @Test
    @DisplayName("NbtException constructor should correctly set error class, error code, and message")
    void testConstructor() {
        int errorClass = NbtException.ERR_NAM_SRVC;

    }

    @Test
    @DisplayName("Should preserve stack trace information")
    void testStackTracePreservation() {
        // When
        SmbException exception = new SmbException("Test exception");

        // Then
        assertNotNull(exception.getStackTrace());
        assertTrue(exception.getStackTrace().length > 0);

        // Should contain this test method in stack trace