assertThat(connect.headers["Proxy-Authorization"]).isEqualTo(credential)
    assertThat(connect.url.encodedPath).isEqualTo("/")
    val get = server.takeRequest()
    assertThat(get.method).isEqualTo("GET")
    assertThat(get.headers["Proxy-Authorization"]).isNull()
    assertThat(get.url.encodedPath).isEqualTo("/foo")
  }

  @Test
  fun preemptiveThenReactiveProxyAuthentication() {

    assertThat(requestUrl.scheme).isEqualTo("http")
    assertThat(requestUrl.host).isEqualTo(server.hostName)
    assertThat(requestUrl.port).isEqualTo(server.port)
    assertThat(requestUrl.encodedPath).isEqualTo("/a/deep/path")
    assertThat(requestUrl.queryParameter("key")).isEqualTo("foo bar")
  }

  @Test
  fun shutdownServerAfterRequest() {
    server.enqueue(
      MockResponse

        minimumDeflateSize = 0L,
        webSocketCloseTimeout = RealWebSocket.CANCEL_AFTER_CLOSE_MILLIS,
      )
    val name = "MockWebServer WebSocket ${request.url.encodedPath}"

    webSocket.initReaderAndWriter(
      name = name,
      socket = socket,
      client = false,
    )

    webSocket.loopReader(fancyResponse)

HSPLokhttp3/HttpUrl;->encodedPassword()Ljava/lang/String;
HSPLokhttp3/HttpUrl;->encodedPath()Ljava/lang/String;
HSPLokhttp3/HttpUrl;->encodedPathSegments()Ljava/util/List;
HSPLokhttp3/HttpUrl;->encodedQuery()Ljava/lang/String;
HSPLokhttp3/HttpUrl;->encodedUsername()Ljava/lang/String;

      }
    }
    val requestA = server.takeRequest()
    assertThat(requestA.url.encodedPath).isEqualTo("/a")
    val requestB = server.takeRequest()
    assertThat(requestB.url.encodedPath).isEqualTo("/b")
    assertThat(requestB.body?.utf8()).isEqualTo(requestBody)
  }

  @Test
  fun postBodyRetransmittedOnFailureRecovery() {

		if n == 0 && total != 0 {
			// Reached EOF, nothing more to be done.
			break
		}

		// We take care of the situation where if n == 0 and total == 0 by creating empty data and parity files.
		blocks, err = e.EncodeData(ctx, buf[:n])
		if err != nil {
			return 0, err
		}

		if err = writer.Write(ctx, blocks); err != nil {
			return 0, err
		}

		total += int64(n)
		if eof {
			break
		}
	}

				// Error conditions should be checked above.
				panic(err)
			}
			enc = e
		})
		return enc
	}
	return e, err
}

// EncodeData encodes the given data and returns the erasure-coded data.
// It returns an error if the erasure coding failed.
func (e *Erasure) EncodeData(ctx context.Context, data []byte) ([][]byte, error) {
	if len(data) == 0 {
		return make([][]byte, e.dataBlocks+e.parityBlocks), nil
	}

            return null;
        }

        return newDictionaryFile(encodePath(path), path, timestamp);
    }

    /**
     * Encodes a file path using Base64 URL-safe encoding.
     *
     * @param path the file path to encode
     * @return the Base64 encoded path
     */
    protected String encodePath(final String path) {

		erasure, err := NewErasure(t.Context(), test.dataBlocks, test.parityBlocks, blockSizeV2)
		if err != nil {
			t.Fatalf("Test %d: failed to create erasure: %v", i, err)
		}
		encoded, err := erasure.EncodeData(t.Context(), buffer)
		if err != nil {
			t.Fatalf("Test %d: failed to encode data: %v", i, err)
		}

		for j := range encoded[:test.missingData] {
			encoded[j] = nil
		}

        ((netdfs.DfsEnumArray1) info.e).s = new netdfs.DfsInfo1[1];
        ((netdfs.DfsEnumArray1) info.e).s[0] = new netdfs.DfsInfo1();
        ((netdfs.DfsEnumArray1) info.e).s[0].entry_path = "encoded_path";

        NdrLong totalentries = new NdrLong(5);

        netdfs.NetrDfsEnumEx enumEx = new netdfs.NetrDfsEnumEx(dfsName, level, prefmaxlen, info, totalentries);