assertEquals("Administrators", wkn.toDisplayString());

            // BUILTIN with unknown type -> falls back to numeric toString
            SID unknownBuiltin = new SID(buildSidT((byte) 1, ident, 544), jcifs.SID.SID_TYPE_UNKNOWN, "BUILTIN", "ignored", false);

    /** The key of the message: Update */
    public static final String LABELS_PROFILE_UPDATE = "{labels.profile.update}";

    /** The key of the message: Back */
    public static final String LABELS_PROFILE_BACK = "{labels.profile.back}";

    /** The key of the message: Current Password */
    public static final String LABELS_PROFILE_placeholder_old_password = "{labels.profile.placeholder_old_password}";

            }
            return null;
        }
        return permission;
    }

    /**
     * Decodes a search role format string back to a permission string.
     * Reverses the encoding process to restore original permission format.
     *
     * @param value the encoded permission string to decode

            throwValidationError(messages -> messages.addErrorsCrudCouldNotFindCrudTable(GLOBAL, id), this::asListHtml);
        });
        saveToken();
        if (form.crudMode.intValue() == CrudMode.EDIT) {
            // back
            form.crudMode = CrudMode.DETAILS;
            return asDetailsHtml();
        }
        form.crudMode = CrudMode.EDIT;
        return asEditHtml();
    }

                    () -> asListHtml(form.dictId));
        });
        saveToken();
        if (form.crudMode.intValue() == CrudMode.EDIT) {
            // back
            form.crudMode = CrudMode.DETAILS;
            return asDetailsHtml();
        }
        form.crudMode = CrudMode.EDIT;
        return asEditHtml();
    }

            // When
            String result = Strings.fromUNIBytes(bytes, 0, bytes.length);

            // Then
            assertEquals(TEST_STRING, result, "Should decode back to original string");
        }

        @Test
        @DisplayName("fromUNIBytes should handle partial byte arrays")
        void testFromUNIBytesPartial() {
            // Given

                    () -> asListHtml(form.dictId));
        });
        saveToken();
        if (form.crudMode.intValue() == CrudMode.EDIT) {
            // back
            form.crudMode = CrudMode.DETAILS;
            return asDetailsHtml();
        }
        form.crudMode = CrudMode.EDIT;
        return asEditHtml();
    }

            throwValidationError(messages -> messages.addErrorsCrudCouldNotFindCrudTable(GLOBAL, id), this::asListHtml);
        });
        saveToken();
        if (form.crudMode.intValue() == CrudMode.EDIT) {
            // back
            form.crudMode = CrudMode.DETAILS;
            return asDetailsHtml(id);
        }
        form.crudMode = CrudMode.EDIT;
        return asEditHtml();
    }

            // Force lease release if break handling times out
            LeaseEntry entry = leases.get(key);
            if (entry != null) {
                log.warn("Lease break timeout for key: {} on path: {}, falling back to no caching", key, entry.getPath());
                // Force to no caching state
                entry.updateState(Smb2LeaseState.SMB2_LEASE_NONE);
            }
            releaseLease(key);

        int n = handle.sendrecv(new byte[3], 0, 3, new byte[8], 64);
        assertEquals(0, n, "Default response length is 0 unless protocol fills it");
    }

    @Test
    @DisplayName("sendrecv falls back to stream write/read when no call/transact")
    void sendrecv_stream_fallback_uses_streams() throws Exception {
        // Arrange - use non-transact, non-call pipe type