}

    @Override
    public int size() {
        // Context header: 16 bytes
        // Name: 4 bytes ("DLse")
        // Padding: 4 bytes (to align data to 8-byte boundary)
        // Standard lease data: 32 bytes
        // Directory-specific data: 20 bytes (CacheScope(4) + MaxCacheAge(8) + Flags(4) + NotificationFilter(4))
        return 16 + 4 + 4 + 32 + 20;
    }

    @Override

):
    await websocket.accept()
    while True:
        data = await websocket.receive_text()
        await websocket.send_text(
            f"Session cookie or query token value is: {cookie_or_token}"
        )
        if q is not None:
            await websocket.send_text(f"Query parameter q is: {q}")

import configurations.ParallelizationMethod
import java.util.SortedSet

class TestClassTime(
    val sourceSet: String,
    val buildTimeMs: Int,
)

data class TestCoverageAndBucketSplits(
    val testCoverageUuid: Int,
    val buckets: List<FunctionalTestBucket>,
)

data class FunctionalTestBucket(
    val subprojects: SortedSet<String>,
    val parallelizationMethod: ParallelizationMethod,
) {

							<c:if test="${eoled}">
								<li class="nav-item" data-bs-toggle="tooltip" data-placement="left" title="<la:message key="labels.eol_error" />">
									<a class="nav-link active" href="${eolLink}" target="_olh"><em class="fas fa-times-circle text-danger"></a>
								</li>
							</c:if>
							<c:if test="${developmentMode}">
								<li class="nav-item" data-bs-toggle="tooltip" data-placement="left"

Pydantic models have a `.model_dump()` method that returns a `dict` with the model's data.

So, if we create a Pydantic object `user_in` like:

```Python
user_in = UserIn(username="john", password="secret", email="******@****.***")
```

and then we call:

```Python
user_dict = user_in.model_dump()
```

we now have a `dict` with the data in the variable `user_dict` (it's a `dict` instead of a Pydantic model object).

	return ARN{TargetID: tid, region: region}
}

// MarshalJSON - encodes to JSON data.
func (tid TargetID) MarshalJSON() ([]byte, error) {
	return json.Marshal(tid.String())
}

// UnmarshalJSON - decodes JSON data.
func (tid *TargetID) UnmarshalJSON(data []byte) error {
	var s string
	if err := json.Unmarshal(data, &s); err != nil {
		return err
	}

	targetID, err := parseTargetID(s)
	if err != nil {

* `id`
* `name`
* `age`

{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[7:18] hl[17:18] *}

#### `HeroCreate` - the *data model* to create a hero { #herocreate-the-data-model-to-create-a-hero }

Now we create a `HeroCreate` model, this is the one that will **validate** the data from the clients.

It has the same fields as `HeroBase`, and it also has `secret_name`.

        byte[] invalidToken = "invalid-relevant-auth-data-token".getBytes();

        // WHEN parsing the auth data
        // THEN a PACDecodingException should be thrown
        assertThrows(PACDecodingException.class, () -> {
            KerberosAuthData.parse(KerberosConstants.AUTH_DATA_RELEVANT, invalidToken, mockKeys);
        }, "Parsing invalid relevant auth data should throw a PACDecodingException.");
    }

  protected final T data;
  protected final T expected;

  private final String suiteName;
  private final String caseDesc;

  SourceSinkTester(F factory, T data, String suiteName, String caseDesc, Method method) {
    super(method.getName());
    this.factory = checkNotNull(factory);
    this.data = checkNotNull(data);
    this.expected = checkNotNull(factory.getExpected(data));

}

func benchmark(b *testing.B, data []string) {
	b.Run("concat naive", func(b *testing.B) {
		b.ResetTimer()
		b.ReportAllocs()
		for b.Loop() {
			concatNaive(data...)
		}
	})
	b.Run("concat fast", func(b *testing.B) {
		b.ResetTimer()
		b.ReportAllocs()
		for b.Loop() {
			concat(data...)
		}
	})
}

func BenchmarkConcatImplementation(b *testing.B) {
	data := make([]string, 2)