assertTrue(result.contains("    <build>"), "Build element should be properly indented");
            assertTrue(result.contains("        <plugins>"), "Plugins element should be properly indented");
            assertTrue(result.contains("            <plugin>"), "Plugin element should be properly indented");
        }

        @Test
        @DisplayName("should format pluginManagement with proper indentation when added")

    void testDcerpcFaultInvalidTag() {
        assertEquals(0x1C000006, DcerpcError.DCERPC_FAULT_INVALID_TAG);
    }

    @Test
    @DisplayName("Should verify DCERPC_FAULT_CONTEXT_MISMATCH constant value")
    void testDcerpcFaultContextMismatch() {
        assertEquals(0x1C00001A, DcerpcError.DCERPC_FAULT_CONTEXT_MISMATCH);
    }

    @Test

            assertTrue(methodNames.contains("getConfig"), "Should contain getConfig method");
            assertTrue(methodNames.contains("unwrap"), "Should contain unwrap method");
            assertTrue(methodNames.contains("getContext"), "Should contain getContext method");
        }

        @Test
        @DisplayName("Should be a public interface")

            NdrShort ndrShort = new NdrShort(inputValue);

            // Then: Value should be masked with 0xFF (lower 8 bits)
            assertEquals(inputValue & 0xFF, ndrShort.value, "Constructor should mask value with 0xFF");
        }

        @Test
        @DisplayName("Should handle zero value correctly")
        void testConstructorZero() {
            // Given/When: Creating NdrShort with zero

			t.Fatalf("Should find saved record")
		}
		return nil
	}); err != nil {
		t.Fatalf("no error should return, but got %v", err)
	}

	if err := DB.First(&User{}, "name = ?", user.Name).Error; err != nil {
		t.Fatalf("Should find saved record")
	}

	if err := DB.First(&User{}, "name = ?", user1.Name).Error; err == nil {
		t.Fatalf("Should not find rollbacked record")
	}

        assertTrue(config.isUseRDMA(), "RDMA should be enabled");
        assertEquals("disni", config.getRdmaProvider(), "Provider should be disni");
        assertEquals(16384, config.getRdmaReadWriteThreshold(), "Threshold should be 16KB");
        assertEquals(131072, config.getRdmaMaxSendSize(), "Max send size should be 128KB");
        assertEquals(131072, config.getRdmaMaxReceiveSize(), "Max receive size should be 128KB");

        // Then - Buffer should have expected size
        assertNotNull(buffer, "Buffer should not be null");
        assertEquals(SmbComTransaction.TRANSACTION_BUF_SIZE, buffer.length, "Buffer should have TRANSACTION_BUF_SIZE");

        // The validation in getBuffer() ensures size is within bounds (0 < size <= 1MB)
        assertTrue(buffer.length > 0, "Buffer size should be positive");

        // Manually unblock
        assertTrue(rateLimiter.unblockIp(ip), "Manual unblock should succeed");

        // Should be allowed again
        assertTrue(rateLimiter.checkAttempt("user7", ip), "Should be allowed after manual unblock");
    }

    @Test
    public void testNullUsername() throws Exception {
        // Null username should be handled gracefully

            // Assert - verify inheritance chain
            assertTrue(msg instanceof samr.SamrConnect2, "Should extend SamrConnect2");
            assertTrue(msg instanceof DcerpcMessage, "Should extend DcerpcMessage");
            assertTrue(msg instanceof NdrObject, "Should extend NdrObject");
        }

        @Test
        @DisplayName("should inherit getOpnum method")
        void testGetOpnumMethod() {
            // Arrange

        String hostName = mockAddress.getHostName();

        // Then
        assertEquals(expectedHostName, hostName, "Should return configured hostname");
        assertNotNull(hostName, "Host name should not be null");
    }

    @Test
    @DisplayName("getHostAddress should return valid IP address string")
    void testGetHostAddressContract() {
        // Given
        String expectedAddress = "192.168.1.100";