/**
     * Compresses data using the specified algorithm.
     *
     * @param data the data to compress
     * @param algorithm the compression algorithm to use
     * @return the compressed data
     * @throws CIFSException if compression fails
     */
    byte[] compress(byte[] data, int algorithm) throws CIFSException;

    /**
     * Compresses data using the specified algorithm with offset and length.

    "data": "aGVsbG8="
}
```

/// tip

`aGVsbG8=` is the base64 encoding of `hello`.

///

And then Pydantic will decode the base64 string and give you the original bytes in the `data` field of the model.

You will receive a response like:

```json
{
  "description": "Some data",
  "content": "hello"
}
```

## Pydantic `bytes` for Output Data { #pydantic-bytes-for-output-data }

    }

    @Test
    void testReadUShort() {
        // Test readUShort with various values
        byte[] data = new byte[4];
        ByteBuffer buffer = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN);

        // Test with a positive value
        buffer.putShort(0, (short) 0x1234);

     * Register roles and labels.
     * @param data The render data.
     */
    protected void registerRolesAndLabels(final RenderData data) {
        RenderDataUtil.register(data, "roleTypeItems", roleTypeService.getRoleTypeList());
    }

    /**
     * Register handler names.
     * @param data The render data.
     */
    protected void registerHandlerNames(final RenderData data) {

	}

	data := SerializerStruct{}

	if err := DB.Create(&data).Error; err != nil {
		t.Fatalf("failed to create data, got error %v", err)
	}

	var result SerializerStruct
	if err := DB.First(&result, data.ID).Error; err != nil {
		t.Fatalf("failed to query data, got error %v", err)
	}

	AssertEqual(t, result, data)

    display: inline-block;
    vertical-align: middle;
}

[data-ty="input"]:before,
[data-ty-prompt]:before {
    margin-right: 0.75em;
    color: var(--color-text-subtle);
}

[data-ty="input"]:before {
    content: '$';
}

[data-ty][data-ty-prompt]:before {
    content: attr(data-ty-prompt);
}

[data-ty-cursor]:after {
    content: attr(data-ty-cursor);
    font-family: monospace;
    margin-left: 0.5em;

│ 1st │ http://minio{1...2}/data{1...4} │ 439 GiB (used) / 561 GiB (total) │ Complete │
│ 2nd │ http://minio{3...4}/data{1...4} │ 329 GiB (used) / 421 GiB (total) │ Active   │
└─────┴─────────────────────────────────┴──────────────────────────────────┴──────────┘
```

		t.Errorf("Should got no error when creating data, but got %v", err)
	}

	if err := DB.Model(&data).Update("password", EncryptedData("xnewpass")).Error; err == nil {
		t.Errorf("Should failed to update data with invalid data")
	}

	if err := DB.Model(&data).Update("password", EncryptedData("newpass")).Error; err != nil {
		t.Errorf("Should got no error update data with valid data, but got %v", err)
	}

    assert response.status_code == 422, response.text

    data = {"items": [["foo", "bar"], ["baz"]]}
    response = client.post("/model-with-tuple/", json=data)
    assert response.status_code == 422, response.text


def test_tuple_with_model_valid():
    data = [{"x": 1, "y": 2}, {"x": 3, "y": 4}]
    response = client.post("/tuple-of-models/", json=data)
    assert response.status_code == 200, response.text

			}
			if withData {
				data, err := readConfig(ctx, objAPI, obj.Name)
				if err != nil {
					// ignore history file if not readable.
					continue
				}

				data, err = decryptData(data, obj.Name)
				if err != nil {
					// ignore history file that cannot be loaded.
					continue
				}

				cfgEntry.Data = string(data)
			}
			configHistory = append(configHistory, cfgEntry)