t.Fatalf("ZH Blog's tags should not be cleared when clear EN Blog's tags")
	}

	if DB.Model(&blog2).Association("LocaleTags").Count() != 0 {
		t.Fatalf("EN Blog's tags should be cleared when clear EN Blog's tags")
	}

	DB.Model(&blog).Association("LocaleTags").Clear()
	if DB.Model(&blog).Association("LocaleTags").Count() != 0 {
		t.Fatalf("ZH Blog's tags should be cleared when clear ZH Blog's tags")
	}

        assertTrue(releaseCount.get() > 0 || acquireCount.get() > 0, "Release and acquire counts should be processed");
    }

    /**
     * Test that trees collection is properly cleared during cleanup.
     */
    @Test
    public void testTreesCollectionCleanup() {
        // Given
        SmbSessionImpl session = new SmbSessionImpl(mockContext, "testhost", "testdomain", mockTransport);

        assertEquals((byte) 0xDE, buf[3], "Sentinel low offset when no chaining");
        assertEquals((byte) 0xDE, buf[4], "Sentinel high offset when no chaining");
        assertNull(block.andx, "andx should be cleared when not chaining");
    }

    @Test
    @DisplayName("writeAndXWireFormat with andx but batching prevented by limit")
    void testWriteAndXWireFormatBatchingPrevented() {

        // Test clearing a flag
        message.setFlag(0b0001, false);
        assertEquals(0b0100, message.getFlags(), "Flag 0b0001 should be cleared.");

        message.setFlag(0b0100, false);
        assertEquals(0, message.getFlags(), "Flag 0b0100 should be cleared.");

        // Test setting a flag that is already set
        message.setFlags(0b1000);
        message.setFlag(0b1000, true);

        assertArrayEquals(testPassword.toCharArray(), passwordBefore, "Password should match before wipe");

        // Wipe the password
        authenticator.secureWipePassword();

        // Verify password is cleared after wipe
        char[] passwordAfter = (char[]) passwordField.get(authenticator);
        assertNull(passwordAfter, "Password should be null after wipe");
    }

    @Test
    @DisplayName("Test session ID generation")

    @DisplayName("parseURL: fragment is moved into path and ref cleared")
    void testParseURL_FragmentMovedToPath() throws MalformedURLException {
        // Arrange & Act
        Handler handler = newHandler();
        URL url = new URL(null, "smb://server/share#frag", handler);

        // Assert: ref is moved into path by Handler.parseURL
        assertNull(url.getRef(), "Ref must be cleared by Handler");

     * We use `fromNullable` instead of `of` because `WeakReference.get()` has a nullable return
     * type.
     *
     * In practice, we are very unlikely to see `null`: The `WeakReference` to the enum constant
     * won't be cleared as long as the enum constant is referenced somewhere, and the enum constant
     * is referenced somewhere for as long as the enum class is loaded. *Maybe in theory* the enum

     *   <li>If this field's value == null because it originally belonged to another thread and that
     *       thread cleared it, we still know that it's not associated with our thread
     *   <li>If this field's value == null because it was associated with our thread and was
     *       cleared, we know that we're not executing inline any more
     * </ul>
     *

			t.Errorf("Test %d - expected %v but received %v",
				i+1, test.result, actual)
		}
	}
}

// Tests RemoveStandardStorageClass method. Expectation is metadata map
// should be cleared of x-amz-storage-class, if it is set to STANDARD
func TestRemoveStandardStorageClass(t *testing.T) {
	tests := []struct {
		name     string
		metadata map[string]string
		want     map[string]string
	}{
		{

        assertEquals(SmbComTransaction.TRANSACTION_BUF_SIZE, buffer2.length, "Reused buffer should have correct size");

        // Note: We don't check if content is cleared as that's not a security requirement
        // The important part is that the buffer is valid and has correct size
    }

    /**
     * Test getBuffers method for transaction buffers.
     */
    @Test