testing/web-platform/tests/serial/serialPort_loopback-manual.https.html

   1 <!DOCTYPE html>
   2 <html>
   3   <head>
   4     <meta charset="utf-8">
   5     <title></title>
   6     <script src="/resources/testharness.js"></script>
   7     <script src="/resources/testharnessreport.js"></script>
   8     <script src="resources/common.js"></script>
   9     <script src="resources/manual.js"></script>
  10   </head>
  11   <body>
  12     <p>
  13       These tests require a connected serial device configured to act as a
  14       "loopback" device, with the transmit and receive pins wired together.
  15     </p>
  16     <script>
  17       manual_serial_test(async (t, port) => {
  18         await port.open({baudRate: 115200, bufferSize: 1024});
  19
  20         // Create something much smaller than bufferSize above.
  21         const data = new Uint8Array(64);
  22         for (let i = 0; i < data.byteLength; ++i)
  23           data[i] = i & 0xff;
  24
  25         const reader = port.readable.getReader();
  26
  27         for (let i = 0; i < 10; ++i) {
  28           const writer = port.writable.getWriter();
  29           writer.write(data);
  30           const writePromise = writer.close();
  31
  32           const value = await readWithLength(reader, data.byteLength);
  33           await writePromise;
  34
  35           compareArrays(value, data);
  36         }
  37
  38         reader.releaseLock();
  39         await port.close();
  40       }, 'Can perform a series of small writes.');
  41
  42       manual_serial_test(async (t, port) => {
  43         await port.open({baudRate: 115200, bufferSize: 1024});
  44
  45         // Create something much larger than bufferSize above.
  46         const data = new Uint8Array(10 * 1024);
  47         for (let i = 0; i < data.byteLength; ++i)
  48           data[i] = (i / 1024) & 0xff;
  49
  50         const reader = port.readable.getReader();
  51
  52         for (let i = 0; i < 10; ++i) {
  53           const writer = port.writable.getWriter();
  54           writer.write(data);
  55           const writePromise = writer.close();
  56
  57           const value = await readWithLength(reader, data.byteLength);
  58           await writePromise;
  59
  60           compareArrays(value, data);
  61         }
  62
  63         reader.releaseLock();
  64         await port.close();
  65       }, 'Can perform a series of large writes.');
  66
  67       manual_serial_test(async (t, port) => {
  68         await port.open({baudRate: 115200, bufferSize: 64});
  69
  70         const writer = port.writable.getWriter();
  71         // |data| is small enough to be completely transmitted.
  72         let data = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
  73         await writer.write(data);
  74
  75         // Wait a little bit for the device to process the incoming data.
  76         await new Promise((resolve) => setTimeout(resolve, 100));
  77         // ...before discarding the receive buffers.
  78         await port.readable.cancel();
  79
  80         data = new Uint8Array([9, 10, 11, 12, 13, 14, 15, 16]);
  81         const reader = port.readable.getReader();
  82         const readPromise = readWithLength(reader, data.byteLength);
  83
  84         // The next block of data should be received successfully.
  85         await writer.write(data);
  86         writer.releaseLock();
  87
  88         const value = await readPromise;
  89         reader.releaseLock();
  90
  91         compareArrays(value, data);
  92
  93         await port.close();
  94       }, 'Canceling the reader discards buffered data.');
  95     </script>
  96   </body>
  97 </html>