byte[] data = new byte[8];
        long low = filetime.longValue();
        long high = filetime.shiftRight(32).longValue();

        // write little-endian
        data[0] = (byte) (low);
        data[1] = (byte) (low >> 8);
        data[2] = (byte) (low >> 16);
        data[3] = (byte) (low >> 24);
        data[4] = (byte) (high);
        data[5] = (byte) (high >> 8);

        @app.post("/example/")
        def example(item: Item = Body(example={"data": "Data in Body example"})):
            return item

    @app.post("/examples/")
    def examples(
        item: Item = Body(
            examples=[
                {"data": "Data in Body examples, example1"},
                {"data": "Data in Body examples, example2"},
            ],
        ),
    ):
        return item

        @Override
        public ModelData intoCache(ModelData data) {
            Model model = (data.getModel() != null) ? data.getModel().clone() : null;
            return new ModelData(data.getSource(), model, data.getGroupId(), data.getArtifactId(), data.getVersion());
        }

        @Override
        public ModelData fromCache(ModelData data) {
            return intoCache(data);
        }
    };

    /**

     */
    public void setData(final byte[] data) {
        this.data = data;
    }

    /**
     * Add a child URL.
     * @param url the request data to add to the child URL set
     */
    public void addUrl(final RequestData url) {
        childUrlSet.add(url);
    }

    /**
     * Add child URLs.
     * @param c the collection of request data to add to the child URL set

		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
		}

        // 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

        }

        @Override
        public byte[] getData() {
            return data;
        }

        @Override
        public String getDataAsString() {
            return data != null ? new String(data) : null;
        }

        @Override
        public void setData(byte[] data) {
            this.data = data;
        }

        @Override
        public String getEncoding() {

		if err != nil {
			t.Fatalf("Test %d: failed to create ErasureStorage: %v", i, err)
		}
		buffer := make([]byte, test.blocksize, 2*test.blocksize)

		data := make([]byte, test.data)
		if _, err = io.ReadFull(rand.Reader, data); err != nil {
			t.Fatalf("Test %d: failed to generate random test data: %v", i, err)
		}
		writers := make([]io.Writer, len(disks))
		for i, disk := range disks {
			if disk == OfflineDisk {
				continue
			}

		</c:if>
		<c:if test="${developmentMode}">
			<li class="nav-item" data-toggle="tooltip" data-placement="left"
				title="<la:message key="labels.development_mode_warning" />">
				<a class="nav-link active" href="${installationLink}" target="_olh"><i class="fa fa-exclamation-triangle text-warning" aria-hidden="true"></i></a></li>
		</c:if>
		<li class="nav-item" data-toggle="tooltip" data-placement="left"

        assertNull(trace.data());
    }

    @Test
    void testChainedTraces() {
        RequestTrace root = new RequestTrace("root", null, "root-data");
        RequestTrace level1 = new RequestTrace("level1", root, "level1-data");
        RequestTrace level2 = new RequestTrace("level2", level1, "level2-data");
        RequestTrace level3 = new RequestTrace(level2, "level3-data");

        // Verify the chain