class AddressTest extends BaseTest {

    @Mock
    private CIFSContext mockContext;

    @Mock
    private Address mockAddress;

    @Test
    @DisplayName("Address interface should define correct method signatures")
    void testInterfaceContract() {
        // Given
        Address address = mockAddress;

        // When & Then - verify interface methods exist and can be called
        assertDoesNotThrow(() -> {

        assertEquals(mockDomainHandle, request.domain_handle, "The domain handle should be set correctly.");
        assertEquals(acctFlags, request.acct_flags, "The account flags should be set correctly.");
        assertEquals(mockSamArray, request.sam, "The sam array should be set correctly.");
        // ptype and flags are protected fields in DcerpcMessage, cannot test directly
    }

import org.gradle.api.tasks.TaskAction;
import org.gradle.api.tasks.util.PatternFilterable;
import org.gradle.api.tasks.util.PatternSet;

import javax.inject.Inject;

/**
 * Checks source files for correct file permissions.
 */
public abstract class FilePermissionsTask extends DefaultTask {

    private final ProjectLayout projectLayout;

    /**
     * A pattern set of which files should be checked.
     */

     * Verifies that the handle, ptype, and flags are correctly initialized.
     */
    @Test
    void testConstructor() {
        // Create an instance of MsrpcLsarClose with the mock handle
        MsrpcLsarClose lsarClose = new MsrpcLsarClose(mockHandle);

        // Verify that the handle passed to the constructor is correctly set in the superclass

        // When: Get challenge
        byte[] key = poolSpy.getChallenge(ctx, address);

        // Then: Should return server key
        assertArrayEquals(expectedKey, key, "Should return correct server key");
        verify(internal).ensureConnected();
    }

    @Test
    @DisplayName("Should wrap IOException in SmbException for getChallenge")
    void testGetChallengeIOException() throws Exception {

    @Mock
    private NdrBuffer mockDeferredBuffer;

    @Nested
    @DisplayName("UUID Tests")
    class UuidTests {

        @Test
        @DisplayName("Should encode UUID correctly")
        void testUuidTEncode() throws NdrException {
            // Given: A UUID with test values
            rpc.uuid_t uuid = new rpc.uuid_t();
            uuid.time_low = 0x12345678;

plugins {
    id("gradlebuild.build-logic.kotlin-dsl-gradle-plugin")
}

description = "Provides a plugin to minify and correct metadata for dependencies used by Gradle"

dependencies {
    implementation("gradlebuild:basics")
    implementation(buildLibs.gson)

        byte[] buffer = new byte[100];
        int dstIndex = 10;
        int bytesWritten = info.encode(buffer, dstIndex);

        // Verify replaceIfExists flag at correct position
        assertEquals(1, buffer[dstIndex]);

        // Verify file name length at correct position
        int nameLength = SMBUtil.readInt4(buffer, dstIndex + 16);
        assertEquals(fileName.getBytes(StandardCharsets.UTF_16LE).length, nameLength);

        // Test that application/xhtml+xml is correctly matched
        Pattern pattern = Pattern.compile(WEB_FILE_RULE_PATTERN);
        assertTrue(pattern.matcher("application/xhtml+xml").matches());
    }

    @Test
    public void test_webFileRulePattern_rdfXml() {
        // Test that application/rdf+xml is correctly matched
        Pattern pattern = Pattern.compile(WEB_FILE_RULE_PATTERN);

        assertEquals("SERVER2", serverList.get(1).oemDomainName);
    }

    /**
     * Test field types match expected types
     */
    @Test
    @DisplayName("Test field types are correct")
    public void testFieldTypes() throws NoSuchFieldException {
        // Verify field types
        assertEquals(byte.class, ServerData.class.getDeclaredField("sflags").getType());