tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

udp_socket.https.html (2823B)

      1 <!DOCTYPE html>
      2 <script src="/resources/testharness.js"></script>
      3 <script src="/resources/testharnessreport.js"></script>
      4 <script src="/resources/test-only-api.js"></script>
      5 <script>
      6 'use strict';
      7 
      8 promise_test(async () => {
      9  const kRequiredDatagrams = 150;
     10  const kRequiredBytes =
     11    kRequiredDatagrams * (kRequiredDatagrams + 1) / 2;
     12 
     13  const boundSocket = new UDPSocket({ localAddress: "127.0.0.1" });
     14  const { localPort: boundLocalPort } = await boundSocket.opened;
     15 
     16  const connectedSocket = new UDPSocket({
     17    remoteAddress: "127.0.0.1",
     18    remotePort: boundLocalPort,
     19  });
     20 
     21  const {
     22    localAddress: clientAddress,
     23    localPort: clientPort
     24  } = await connectedSocket.opened;
     25 
     26  const boundEchoLoop = (async() => {
     27    let bytesEchoed = 0;
     28 
     29    const { readable, writable } = await boundSocket.opened;
     30    const reader = readable.getReader();
     31    const writer = writable.getWriter();
     32 
     33    while (bytesEchoed < kRequiredBytes) {
     34      const { value: { data, remoteAddress, remotePort }, done } = await reader.read();
     35      assert_false(done);
     36      assert_equals(remoteAddress, clientAddress);
     37      assert_equals(remotePort, clientPort);
     38      for (let index = 0; index < data.length; index++) {
     39        assert_equals(data[index], bytesEchoed % 256);
     40        bytesEchoed++;
     41      }
     42      await writer.write({ data, remoteAddress, remotePort });
     43    }
     44 
     45    assert_equals(bytesEchoed, kRequiredBytes);
     46    reader.releaseLock();
     47    writer.releaseLock();
     48  })();
     49 
     50  const connectedSendLoop = (async () => {
     51    let bytesWritten = 0;
     52    let chunkLength = 0;
     53 
     54    const { writable } = await connectedSocket.opened;
     55    const writer = writable.getWriter();
     56 
     57    while (bytesWritten < kRequiredBytes) {
     58      chunkLength = Math.min(chunkLength + 1, kRequiredBytes - bytesWritten);
     59      let chunk = new Uint8Array(chunkLength);
     60      for (let index = 0; index < chunkLength; index++) {
     61        chunk[index] = bytesWritten % 256;
     62        bytesWritten++;
     63      }
     64      await writer.ready;
     65      await writer.write({ data: chunk });
     66    }
     67    assert_equals(bytesWritten, kRequiredBytes);
     68    writer.releaseLock();
     69  })();
     70 
     71  const connectedReadLoop = (async () => {
     72    let bytesRead = 0;
     73 
     74    const { readable } = await connectedSocket.opened;
     75    const reader = readable.getReader();
     76 
     77    while (bytesRead < kRequiredBytes) {
     78      const { value: { data }, done } = await reader.read();
     79      assert_false(done);
     80      for (let index = 0; index < data.length; index++) {
     81        assert_equals(data[index], bytesRead % 256);
     82        bytesRead++;
     83      }
     84    }
     85    assert_equals(bytesRead, kRequiredBytes);
     86 
     87    reader.releaseLock();
     88  })();
     89 
     90  await connectedReadLoop;
     91 
     92  await boundSocket.close();
     93  await connectedSocket.close();
     94 }, "UDPSocket (connected) exchanges datagrams with UDPSocket (bound)");
     95 </script>