if err != nil {
			t.Fatalf("Test %d: failed to create ErasureStorage: %v", i, err)
		}
		disks := setup.disks
		data := make([]byte, test.data)
		if _, err = io.ReadFull(crand.Reader, data); err != nil {
			t.Fatalf("Test %d: failed to generate random test data: %v", i, err)
		}

		writeAlgorithm := test.algorithm
		if !test.algorithm.Available() {
			writeAlgorithm = DefaultBitrotAlgorithm
		}

inner_default = APIRouter(prefix="/default")


@inner_strict.post("/items/")
async def inner_strict_post(data: dict):
    return data


@inner_default.post("/items/")
async def inner_default_post(data: dict):
    return data


outer_router.include_router(inner_strict)
outer_router.include_router(inner_default)
app_nested.include_router(outer_router)

def test_decimal_encoder_float():
    data = {"value": Decimal(1.23)}
    assert jsonable_encoder(data) == {"value": 1.23}


def test_decimal_encoder_int():
    data = {"value": Decimal(2)}
    assert jsonable_encoder(data) == {"value": 2}


def test_decimal_encoder_nan():
    data = {"value": Decimal("NaN")}
    assert isnan(jsonable_encoder(data)["value"])


def test_decimal_encoder_infinity():

@app.get("/items/stream-sse-event", response_class=EventSourceResponse)
async def sse_items_event():
    yield ServerSentEvent(data="hello", event="greeting", id="1")
    yield ServerSentEvent(data={"key": "value"}, event="json-data", id="2")
    yield ServerSentEvent(comment="just a comment")
    yield ServerSentEvent(data="retry-test", retry=5000)


@app.get("/items/stream-mixed", response_class=EventSourceResponse)

        raise RuntimeError(response.text)
    data = response.json()
    if "errors" in data:
        logging.error(f"Errors in response, after: {after}, category_id: {category_id}")
        logging.error(data["errors"])
        logging.error(response.text)
        raise RuntimeError(response.text)
    return cast(dict[str, Any], data)


def get_graphql_translation_discussions(

    void testInvalidParameters() {
        // Given
        byte[] data = createTestData(32);

        // When/Then
        assertThrows(IndexOutOfBoundsException.class, () -> {
            Hexdump.toHexString(data, -1, 16);
        });

        assertThrows(IndexOutOfBoundsException.class, () -> {
            Hexdump.toHexString(data, 0, data.length + 1);
        });

        // Data block: 2 entries
        byte[] data = new byte[100];
        // Entry 1: SHARE1, type 0 (Disk), remark "Remark 1"
        System.arraycopy("SHARE1".getBytes(StandardCharsets.US_ASCII), 0, data, 0, 6);
        data[14] = 0x00;
        data[15] = 0x00; // type = 0
        data[16] = 40;
        data[17] = 0;
        data[18] = 0;
        data[19] = 0; // remark offset

    checkSha1(expected, key, data.getBytes(UTF_8));
  }

  private static void checkSha1(String expected, byte[] key, byte[] data) {
    checkHmac(expected, hmacSha1(key), data);
  }

  private static void checkMd5(String expected, byte[] key, String data) {
    checkMd5(expected, key, data.getBytes(UTF_8));
  }

        }
    }

    @Nested
    @DisplayName("Data Setting Tests")
    class DataSettingTests {

        @Test
        @DisplayName("Should set data with offset and length")
        void testSetData() {
            byte[] data = new byte[1024];
            new Random().nextBytes(data);

            assertDoesNotThrow(() -> request.setData(data, 0, data.length));
        }

        @Test

        // Test that different data produces different results
        byte[] data1 = "data1".getBytes();
        byte[] data2 = "data2".getBytes();

        HMACT64 hmac1 = new HMACT64(TEST_KEY);
        HMACT64 hmac2 = new HMACT64(TEST_KEY);

        hmac1.engineUpdate(data1, 0, data1.length);
        hmac2.engineUpdate(data2, 0, data2.length);

        byte[] result1 = hmac1.engineDigest();