private Smb2WriteResponse mockWriteResponse;

    private SmbFileOutputStream outputStream;

    @BeforeEach
    void setUp() {
        // Common setup for most tests
        lenient().when(mockFileHandle.getTree()).thenReturn(mockTreeHandle);
        lenient().when(mockTreeHandle.getConfig()).thenReturn(mockConfig);
    }

    @Test
    void testWriteSingleByte() throws IOException, CIFSException {
        // Given

                if (headerFieldMap != null) {
                    for (final Map.Entry<String, List<String>> entry : headerFieldMap.entrySet()) {
                        responseData.addMetaData(entry.getKey(), entry.getValue());
                    }
                }

                if (file.canRead()) {
                    final MimeTypeHelper mimeTypeHelper = crawlerContainer.getComponent("mimeTypeHelper");

            assertThrows(DcerpcException.class, () -> DcerpcHandle.getHandle("unsupported:\\\\server", mockContext));
        }
    }

    @Nested
    @DisplayName("Getter Tests")
    class GetterTests {

        @Test
        @DisplayName("Should return correct values from getters")
        void testGetters() throws CIFSException {

        }

        int maxUaLength = -1;
        Directive matchedDirective = null;
        for (final Map.Entry<Pattern, Directive> entry : directiveMap.entrySet()) {
            if (entry.getKey().matcher(target).find()) {
                final Directive directive = entry.getValue();
                final String ua = directive.getUserAgent();
                int uaLength = 0;

    // Format: TOK_ID(2 bytes) | OID_LEN(2 bytes) | OID_DER | NAME_LEN(4 bytes) | NAME(bytes)
    private static byte[] buildExportName(Oid mech, String name) throws GSSException {
        byte[] der = mech.getDER();
        byte[] nb = name.getBytes();
        int len = 2 + 2 + der.length + 4 + nb.length;
        byte[] out = new byte[len];
        int i = 0;
        out[i++] = 0x04; // TOK_ID[0]

                                HashMap::putAll));
            }
            propMap.put(DEFAULT_LABEL_VALUES, map);
        }
        return map.entrySet().stream().flatMap(e -> {
            final String key = e.getKey();
            if (StringUtil.isEmpty(key) || userBean
                    .map(user -> stream(user.getRoles()).get(stream -> stream.anyMatch(s -> (ROLE_VALUE_PREFIX + s).equals(key)))

            getObjectTags(getObjectName(path, name)).entrySet().forEach(e -> {
                final int index = tags.size() / 2 + 1;
                tags.put("name" + index, e.getKey());
                tags.put("value" + index, e.getValue());
            });
            RenderDataUtil.register(data, "savedTags", tags);
        });
    }

    /**

        void testInitialTotalBytesWrittenValue() {
            assertEquals(0, response.getTotalBytesWritten());
        }
    }

    @Nested
    @DisplayName("Getter Tests")
    class GetterTests {

        @Test
        @DisplayName("Should get chunksWritten value")
        void testGetChunksWritten() {
            // Initial value should be 0

        // Setter should update the field
        transformer.setName("setterAccess");
        assertEquals("setterAccess", transformer.name);

        // Field modification should be reflected in getter
        transformer.name = "modifiedField";
        assertEquals("modifiedField", transformer.getName());
    }

    /**
     * Test name persistence across operations
     */

    StringHolder holder = new StringHolder();
    holder.string = "one";
    Entry<String, Integer> entry =
        new AbstractMapEntry<String, Integer>() {
          @Override
          public String getKey() {
            return holder.string;
          }

          @Override
          public Integer getValue() {
            return 1;
          }
        };

    builder.put(entry);