this.rawData = rawData;
        if (rawData != null) {
            data = null;
        }
    }

    /**
     * Get the raw data.
     * @return rawData
     */
    public Object getRawData() {
        return rawData;
    }

    /**
     * Set the serializer.
     * @param serializer the serializer function to convert raw data to byte array
     */

     */
    @Test
    void testAvSingleHostRawConstructor() {
        byte[] rawData = new byte[48]; // 8 (size/zero) + 8 (customData) + 32 (machineId)
        // Simulate some data
        rawData[0] = 48; // size
        rawData[16] = 0x01; // machineId start
        rawData[17] = 0x02;

        AvSingleHost avSingleHost = new AvSingleHost(rawData);

        assertNotNull(avSingleHost);

    public void test_setRawData() {
        // ## Arrange ##
        final ResultData resultData = new ResultData();
        final Object rawData = new Object();

        // ## Act ##
        resultData.setRawData(rawData);

        // ## Assert ##
        assertEquals(rawData, resultData.getRawData());

        assertNull(resultData.serializer);
        try {
            resultData.getData();
            fail();

            final ResultData resultData = transformer.transform(responseData);
            final Object rawData = resultData.getRawData();
            if (rawData != null) {
                @SuppressWarnings("unchecked")
                final Map<String, Object> responseDataMap = (Map<String, Object>) rawData;
                return responseDataMap;
            } else {
                final byte[] data = resultData.getData();

                    final ResultData resultData = transformer.transform(responseData);
                    final Object rawData = resultData.getRawData();
                    if (rawData != null) {
                        @SuppressWarnings("unchecked")
                        final Map<String, Object> responseDataMap = (Map<String, Object>) rawData;
                        mergeResponseData(dataMap, responseDataMap);
                    } else {

 */
class HpackRoundTripTest : HpackDecodeTestBase() {
  internal class StoriesTestProvider : SimpleProvider() {
    override fun arguments(): List<Any> = createStories(RAW_DATA)
  }

  private val bytesOut = Buffer()
  private val hpackWriter = Hpack.Writer(out = bytesOut)

  @ParameterizedTest
  @ArgumentsSource(StoriesTestProvider::class)
  fun testRoundTrip(story: Story) {

	outReq.URL = copyURL(outReq.URL)
	outReq.URL.Scheme = target.Scheme
	outReq.URL.Host = target.Host

	u := f.getURLFromRequest(outReq)

	outReq.URL.Path = u.Path
	outReq.URL.RawPath = u.RawPath
	outReq.URL.RawQuery = u.RawQuery
	outReq.RequestURI = "" // Outgoing request should not have RequestURI

	// Do not pass client Host header unless requested.
	if !f.PassHost {
		outReq.Host = target.Host

		}
		if host, port, err := net.SplitHostPort(nodeName); err == nil {
			if port == "443" || port == "80" {
				nodeName = host
			}
		}

		// Calculate reqPath
		reqPath := r.URL.RawPath
		if reqPath == "" {
			reqPath = r.URL.Path
		}

		// Calculate function name
		funcName := tc.FuncName
		if funcName == "" {
			funcName = "<unknown>"
		}

		t := madmin.TraceInfo{

	if expiresStr == "" {
		expiresStr = strconv.FormatInt(epochExpires, 10)
		req.Header.Set("Expires", expiresStr)
	}

	// url.RawPath will be valid if path has any encoded characters, if not it will
	// be empty - in which case we need to consider url.Path (bug in net/http?)
	encodedResource := req.URL.RawPath
	encodedQuery := req.URL.RawQuery
	if encodedResource == "" {
		splits := strings.SplitN(req.URL.Path, "?", 2)

pkg net/mail, type AddressParser struct, WordDecoder *mime.WordDecoder
pkg net/smtp, method (*Client) TLSConnectionState() (tls.ConnectionState, bool)
pkg net/url, method (*URL) EscapedPath() string
pkg net/url, type URL struct, RawPath string
pkg os, func LookupEnv(string) (string, bool)
pkg os/signal, func Ignore(...os.Signal)
pkg os/signal, func Reset(...os.Signal)
pkg reflect, func ArrayOf(int, Type) Type