CustomSmbTree inner = middle.unwrap(CustomSmbTree.class);

        assertNotNull(middle, "Middle tree should not be null");
        assertNotNull(inner, "Inner tree should not be null");
        assertSame(middleTree, middle, "Should return correct middle tree");
        assertSame(innerTree, inner, "Should return correct inner tree");
    }

    /**
     * Test for unwrap with incompatible type.

        }

        @Test
        @DisplayName("Should throw exception for invalid structure size")
        void testReadInvalidStructureSize() {
            // Create buffer with invalid structure size
            byte[] buffer = new byte[64];
            SMBUtil.writeInt2(23, buffer, 0); // Invalid size (should be 24)

            SMBProtocolDecodingException exception =

        // Test the no-argument constructor
        ConnectionTimeoutException exception = new ConnectionTimeoutException();
        assertNull(exception.getMessage(), "Message should be null for no-arg constructor");
        assertNull(exception.getCause(), "Cause should be null for no-arg constructor");
    }

    @Test
    void testStringConstructor() {
        // Test the constructor with a message

 * and whether the crawling process should be aborted.
 */
public class DataStoreCrawlingException extends CrawlingAccessException {

    private static final long serialVersionUID = 1L;

    /**
     * The URL where the crawling error occurred.
     */
    private final String url;

    /**
     * Flag indicating whether the crawling process should be aborted.
     */
    private final boolean abort;

        SMBProtocolDowngradeException ex = new SMBProtocolDowngradeException();

        // Assert - message and cause are null
        assertNull(ex.getMessage(), "Default constructor should have null message");
        assertNull(ex.getCause(), "Default constructor should have null cause");

        // Assert - toString shows class name when message is null
        assertEquals(SMBProtocolDowngradeException.class.getName(), ex.toString());

		t.Errorf("should returns record not found error, but got %v", err)
	}

	for _, user := range []User{users[0], users[2]} {
		result = User{}
		if err := DB.Where("id = ?", user.ID).First(&result).Error; err != nil {
			t.Errorf("no error should returns when query %v, but got %v", user.ID, err)
		}
	}

        // 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

    }

    @Test
    void testRetainPayload() {
        // Initially, retainPayload should be false
        assertFalse(message.isRetainPayload(), "isRetainPayload should be false initially");

        // Call retainPayload and check if it becomes true
        message.retainPayload();
        assertTrue(message.isRetainPayload(), "isRetainPayload should be true after calling retainPayload");
    }

    @Test

        d.readBytesWireFormat(buf, 0);

        // After a full read both flags should be set and hasMore should be false
        assertTrue(d.getParametersDone(), "parametersDone should be true after reading");
        assertTrue(d.getDataDone(), "dataDone should be true after reading");
        assertFalse(d.getHasMore(), "hasMore should be false when both packets are fully read");
    }

    /**

  @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();