// Reserved1 (2 bytes) - should be 0 (bytes were initialized to 0xCC, so they weren't written)
        // This is expected behavior - the reserved fields are not explicitly written to 0

        // Reserved2 (4 bytes) - should be 0 (bytes were initialized to 0xCC, so they weren't written)
        // This is expected behavior - the reserved fields are not explicitly written to 0

        // FileId (16 bytes) - should match our test file ID

    @Mock
    private Configuration mockConfig;

    @Mock
    private Name mockName;

    private NodeStatusRequest nodeStatusRequest;

    @BeforeEach
    void setUp() {
        // Setup default mock behavior
        lenient().when(mockConfig.getNetbiosScope()).thenReturn("DEFAULT.SCOPE");
        lenient().when(mockConfig.getOemEncoding()).thenReturn("UTF-8");

        // Setup mock name

                    null // --model
                    ));

            // Should apply default behavior when all options are explicitly disabled
            assertTrue(
                    strategy.isApplicable(context),
                    "Strategy should apply default behavior when all options are disabled");
        }
    }

    @Nested
    @DisplayName("Duplicate Dependency Fixes")

 *       String}.
 *   <li>{@code getElement} on a {@code Multiset.Entry<@Nullable String>} returns {@code @Nullable
 *       String}.
 * </ul>
 *
 * This is the same behavior as type-variable usages have to Kotlin and to the Checker Framework.
 * Contrast the method above to:
 *
 * <ul>
 *   <li>methods whose return type is a type variable but which can never return {@code null},

 *       String}.
 *   <li>{@code getElement} on a {@code Multiset.Entry<@Nullable String>} returns {@code @Nullable
 *       String}.
 * </ul>
 *
 * This is the same behavior as type-variable usages have to Kotlin and to the Checker Framework.
 * Contrast the method above to:
 *
 * <ul>
 *   <li>methods whose return type is a type variable but which can never return {@code null},

 *       String}.
 *   <li>{@code getElement} on a {@code Multiset.Entry<@Nullable String>} returns {@code @Nullable
 *       String}.
 * </ul>
 *
 * This is the same behavior as type-variable usages have to Kotlin and to the Checker Framework.
 * Contrast the method above to:
 *
 * <ul>
 *   <li>methods whose return type is a type variable but which can never return {@code null},

     *
     * TODO(cpovirk): decide what the best long-term action here is: force users
     * to suppress (as we do now), stop testing entrySet().add() at all, make
     * entrySet().add() tests tolerant of either behavior, introduce a map
     * feature for entrySet() that supports add(), or something else
     */
    return asList(
        getAddUnsupportedNotPresentMethod(),
        getAddAllUnsupportedNonePresentMethod(),

 *       String}.
 *   <li>{@code getElement} on a {@code Multiset.Entry<@Nullable String>} returns {@code @Nullable
 *       String}.
 * </ul>
 *
 * This is the same behavior as type-variable usages have to Kotlin and to the Checker Framework.
 * Contrast the method above to:
 *
 * <ul>
 *   <li>methods whose return type is a type variable but which can never return {@code null},

class SmbComCreateDirectoryTest {

    private Configuration mockConfig;

    @BeforeEach
    void setUp() {
        // Mock the Configuration object
        mockConfig = mock(Configuration.class);
        // Define behavior for the OEM encoding, which is used by writeString
        when(mockConfig.getOemEncoding()).thenReturn(StandardCharsets.UTF_8.name());
    }

    @Test
    void testConstructor() {

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;

/**
 * Comprehensive test suite for Address interface.
 * Tests the contract and behavior of Address implementations.
 */
@DisplayName("Address Interface Tests")
class AddressTest extends BaseTest {

    @Mock
    private CIFSContext mockContext;

    @Mock
    private Address mockAddress;