)
def test_post(path):
    data = {"a": 2, "b": "foo"}
    response = client.post(path, json=data)
    assert response.status_code == 200, response.text
    assert data == response.json()


@pytest.mark.parametrize(
    "path", ["/a/compute", "/a/compute/", "/b/compute", "/b/compute/"]
)
def test_post_invalid(path):
    data = {"a": "bar", "b": "foo"}
    response = client.post(path, json=data)

 * Implementations can specify how long cached data should be retained.
 *
 * @since 4.0.0
 */
@Experimental
public interface CacheMetadata {

    /**
     * Returns the cache retention that should be applied to the associated data.
     *
     * @return The CacheRetention indicating how long data should be retained, or null if
     *         no specific cache retention is defined
     */

    /**
     * Do not instantiate.
     */
    protected Base64Util() {
    }

    /**
     * Encodes data in Base64.
     * <p>
     * This method uses {@link java.util.Base64.Encoder} for encoding.
     * </p>
     *
     * @param inData
     *            The data to encode
     * @return The encoded data, or an empty string if the input is null or empty
     */
    public static String encode(final byte[] inData) {

    protected int parameterDisplacement;
    /** Number of data bytes being sent in this request */
    protected int dataCount;
    /** Offset from the start of the SMB header to the data bytes */
    protected int dataOffset;
    /** Displacement of these data bytes from the start of the total data block */
    protected int dataDisplacement;

    /** Total number of parameter bytes to be sent */

            searchPaging(data, form);
        });
    }

    /**
     * Search with paging.
     * @param data The render data.
     * @param form The search form.
     */
    protected void searchPaging(final RenderData data, final SearchForm form) {

        // Create test data and dump from offset
        byte[] data = createTestData(64);
        int offset = 16;
        int length = 32;

        Hexdump.hexdump(ps, data, offset, length);
        String output = baos.toString();

        assertNotNull(output);
        // Should start at offset 0 in display but show data from offset 16
        assertTrue(output.contains("00000:"));

    }

    @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"