// READ_CACHING for directories means:
    // - Can cache directory enumeration results
    // - Can cache file existence queries
    // - Can cache basic file attributes
    
    // HANDLE_CACHING for directories means:
    // - Can keep directory handle open
    // - Can cache subdirectory handles
    
    // WRITE_CACHING for directories means:

        SmbFile file = new SmbFile(baseUrl + "shared/attributes.txt", context);
        file.createNewFile();

        // Test basic attributes
        assertTrue(file.canRead(), "File should be readable");
        assertTrue(file.canWrite(), "File should be writable");

        int attributes = file.getAttributes();
        assertTrue(attributes >= 0, "Attributes should be valid");
    }

    @Test

	if len(ldapPolicies) == 0 {
		return nil, errSFTPUserHasNoPolicies
	}

	claims := make(map[string]any)
	for attribKey, attribValue := range lookupResult.Attributes {
		// we skip multi-value attributes here, as they cannot
		// be stored in the critical options.
		if len(attribValue) != 1 {
			continue
		}

		if attribKey == "sshPublicKey" && key != nil {

        @Test
        @DisplayName("Should encode RID with attribute correctly")
        void testEncode() throws NdrException {
            // Given: RID with attribute
            samr.SamrRidWithAttribute ridWithAttribute = new samr.SamrRidWithAttribute();
            ridWithAttribute.rid = 100;
            ridWithAttribute.attributes = 200;

            // When: Encoding

Wir können zum Beispiel ein `Image`-Modell definieren.

{* ../../docs_src/body_nested_models/tutorial004_py310.py hl[7:9] *}

### Das Kindmodell als Typ verwenden

Und dann können wir es als Typ eines Attributes verwenden.

{* ../../docs_src/body_nested_models/tutorial004_py310.py hl[18] *}

Das würde bedeuten, dass **FastAPI** einen Body erwartet wie:

```JSON
{
    "name": "Foo",

     */
    @Execute
    public JsonResponse<ApiResult> post$setting(final CreateBody body) {
        validateApi(body, messages -> {});
        validateAttributes(body.attributes, this::throwValidationErrorApi);
        body.crudMode = CrudMode.CREATE;
        final Group entity = getGroup(body).orElseGet(() -> {
            throwValidationErrorApi(messages -> {

        @Test
        @DisplayName("DosFileFilter wildcard and attributes are preserved through unwrap")
        void dosFileFilter_preservesFieldsThroughUnwrap() throws Exception {
            // Test with various wildcard patterns and attribute masks
            String[] wildcards = { "*.txt", "test*", null };
            int[] attributes = { 0x10, 0x20, 0x07 };

            for (int i = 0; i < wildcards.length; i++) {

///

////

/// info

In Pydantic version 1 the configuration was done in an internal class `Config`, in Pydantic version 2 it's done in an attribute `model_config`. This attribute takes a `dict`, and to get autocompletion and inline errors you can import and use `SettingsConfigDict` to define that `dict`.

///

                        final Node node = nodeList.item(i);
                        final NamedNodeMap attributes = node.getAttributes();
                        if (attributes != null) {
                            final Node classAttr = attributes.getNamedItem("class");
                            if (classAttr != null) {
                                final String value = classAttr.getNodeValue();

        } catch (final UnsupportedEncodingException ex) {
            throw new IORuntimeException(ex);
        }
    }

    /**
     * Encodes the value of an attribute.
     *
     * @param s
     *            The attribute value.
     * @return The encoded attribute value.
     */
    public static String encodeAttrQuot(final String s) {
        if (s == null) {
            return null;
        }