From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- ...test_nsIBufferedOutputStream_writeFrom_block.js | 193 +++++++++++++++++++++ 1 file changed, 193 insertions(+) create mode 100644 netwerk/test/unit/test_nsIBufferedOutputStream_writeFrom_block.js (limited to 'netwerk/test/unit/test_nsIBufferedOutputStream_writeFrom_block.js') diff --git a/netwerk/test/unit/test_nsIBufferedOutputStream_writeFrom_block.js b/netwerk/test/unit/test_nsIBufferedOutputStream_writeFrom_block.js new file mode 100644 index 0000000000..577b2c6da8 --- /dev/null +++ b/netwerk/test/unit/test_nsIBufferedOutputStream_writeFrom_block.js @@ -0,0 +1,193 @@ +"use strict"; + +var CC = Components.Constructor; + +var Pipe = CC("@mozilla.org/pipe;1", Ci.nsIPipe, "init"); +var BufferedOutputStream = CC( + "@mozilla.org/network/buffered-output-stream;1", + Ci.nsIBufferedOutputStream, + "init" +); +var ScriptableInputStream = CC( + "@mozilla.org/scriptableinputstream;1", + Ci.nsIScriptableInputStream, + "init" +); + +// Verify that pipes behave as we expect. Subsequent tests assume +// pipes behave as demonstrated here. +add_test(function checkWouldBlockPipe() { + // Create a pipe with a one-byte buffer + var pipe = new Pipe(true, true, 1, 1); + + // Writing two bytes should transfer only one byte, and + // return a partial count, not would-block. + Assert.equal(pipe.outputStream.write("xy", 2), 1); + Assert.equal(pipe.inputStream.available(), 1); + + do_check_throws_nsIException( + () => pipe.outputStream.write("y", 1), + "NS_BASE_STREAM_WOULD_BLOCK" + ); + + // Check that nothing was written to the pipe. + Assert.equal(pipe.inputStream.available(), 1); + run_next_test(); +}); + +// A writeFrom to a buffered stream should return +// NS_BASE_STREAM_WOULD_BLOCK if no data was written. +add_test(function writeFromBlocksImmediately() { + // Create a full pipe for our output stream. This will 'would-block' when + // written to. + var outPipe = new Pipe(true, true, 1, 1); + Assert.equal(outPipe.outputStream.write("x", 1), 1); + + // Create a buffered stream, and fill its buffer, so the next write will + // try to flush. + var buffered = new BufferedOutputStream(outPipe.outputStream, 10); + Assert.equal(buffered.write("0123456789", 10), 10); + + // Create a pipe with some data to be our input stream for the writeFrom + // call. + var inPipe = new Pipe(true, true, 1, 1); + Assert.equal(inPipe.outputStream.write("y", 1), 1); + + Assert.equal(inPipe.inputStream.available(), 1); + do_check_throws_nsIException( + () => buffered.writeFrom(inPipe.inputStream, 1), + "NS_BASE_STREAM_WOULD_BLOCK" + ); + + // No data should have been consumed from the pipe. + Assert.equal(inPipe.inputStream.available(), 1); + + run_next_test(); +}); + +// A writeFrom to a buffered stream should return a partial count if any +// data is written, when the last Flush call can only flush a portion of +// the data. +add_test(function writeFromReturnsPartialCountOnPartialFlush() { + // Create a pipe for our output stream. This will accept five bytes, and + // then 'would-block'. + var outPipe = new Pipe(true, true, 5, 1); + + // Create a reference to the pipe's readable end that can be used + // from JavaScript. + var outPipeReadable = new ScriptableInputStream(outPipe.inputStream); + + // Create a buffered stream whose buffer is too large to be flushed + // entirely to the output pipe. + var buffered = new BufferedOutputStream(outPipe.outputStream, 7); + + // Create a pipe to be our input stream for the writeFrom call. + var inPipe = new Pipe(true, true, 15, 1); + + // Write some data to our input pipe, for the rest of the test to consume. + Assert.equal(inPipe.outputStream.write("0123456789abcde", 15), 15); + Assert.equal(inPipe.inputStream.available(), 15); + + // Write from the input pipe to the buffered stream. The buffered stream + // will fill its seven-byte buffer; and then the flush will only succeed + // in writing five bytes to the output pipe. The writeFrom call should + // return the number of bytes it consumed from inputStream. + Assert.equal(buffered.writeFrom(inPipe.inputStream, 11), 7); + Assert.equal(outPipe.inputStream.available(), 5); + Assert.equal(inPipe.inputStream.available(), 8); + + // The partially-successful Flush should have created five bytes of + // available space in the buffered stream's buffer, so we should be able + // to write five bytes to it without blocking. + Assert.equal(buffered.writeFrom(inPipe.inputStream, 5), 5); + Assert.equal(outPipe.inputStream.available(), 5); + Assert.equal(inPipe.inputStream.available(), 3); + + // Attempting to write any more data should would-block. + do_check_throws_nsIException( + () => buffered.writeFrom(inPipe.inputStream, 1), + "NS_BASE_STREAM_WOULD_BLOCK" + ); + + // No data should have been consumed from the pipe. + Assert.equal(inPipe.inputStream.available(), 3); + + // Push the rest of the data through, checking that it all came through. + Assert.equal(outPipeReadable.available(), 5); + Assert.equal(outPipeReadable.read(5), "01234"); + // Flush returns NS_ERROR_FAILURE if it can't transfer the full amount. + do_check_throws_nsIException(() => buffered.flush(), "NS_ERROR_FAILURE"); + Assert.equal(outPipeReadable.available(), 5); + Assert.equal(outPipeReadable.read(5), "56789"); + buffered.flush(); + Assert.equal(outPipeReadable.available(), 2); + Assert.equal(outPipeReadable.read(2), "ab"); + Assert.equal(buffered.writeFrom(inPipe.inputStream, 3), 3); + buffered.flush(); + Assert.equal(outPipeReadable.available(), 3); + Assert.equal(outPipeReadable.read(3), "cde"); + + run_next_test(); +}); + +// A writeFrom to a buffered stream should return a partial count if any +// data is written, when the last Flush call blocks. +add_test(function writeFromReturnsPartialCountOnBlock() { + // Create a pipe for our output stream. This will accept five bytes, and + // then 'would-block'. + var outPipe = new Pipe(true, true, 5, 1); + + // Create a reference to the pipe's readable end that can be used + // from JavaScript. + var outPipeReadable = new ScriptableInputStream(outPipe.inputStream); + + // Create a buffered stream whose buffer is too large to be flushed + // entirely to the output pipe. + var buffered = new BufferedOutputStream(outPipe.outputStream, 7); + + // Create a pipe to be our input stream for the writeFrom call. + var inPipe = new Pipe(true, true, 15, 1); + + // Write some data to our input pipe, for the rest of the test to consume. + Assert.equal(inPipe.outputStream.write("0123456789abcde", 15), 15); + Assert.equal(inPipe.inputStream.available(), 15); + + // Write enough from the input pipe to the buffered stream to fill the + // output pipe's buffer, and then flush it. Nothing should block or fail, + // but the output pipe should now be full. + Assert.equal(buffered.writeFrom(inPipe.inputStream, 5), 5); + buffered.flush(); + Assert.equal(outPipe.inputStream.available(), 5); + Assert.equal(inPipe.inputStream.available(), 10); + + // Now try to write more from the input pipe than the buffered stream's + // buffer can hold. It will attempt to flush, but the output pipe will + // would-block without accepting any data. writeFrom should return the + // correct partial count. + Assert.equal(buffered.writeFrom(inPipe.inputStream, 10), 7); + Assert.equal(outPipe.inputStream.available(), 5); + Assert.equal(inPipe.inputStream.available(), 3); + + // Attempting to write any more data should would-block. + do_check_throws_nsIException( + () => buffered.writeFrom(inPipe.inputStream, 3), + "NS_BASE_STREAM_WOULD_BLOCK" + ); + + // No data should have been consumed from the pipe. + Assert.equal(inPipe.inputStream.available(), 3); + + // Push the rest of the data through, checking that it all came through. + Assert.equal(outPipeReadable.available(), 5); + Assert.equal(outPipeReadable.read(5), "01234"); + // Flush returns NS_ERROR_FAILURE if it can't transfer the full amount. + do_check_throws_nsIException(() => buffered.flush(), "NS_ERROR_FAILURE"); + Assert.equal(outPipeReadable.available(), 5); + Assert.equal(outPipeReadable.read(5), "56789"); + Assert.equal(buffered.writeFrom(inPipe.inputStream, 3), 3); + buffered.flush(); + Assert.equal(outPipeReadable.available(), 5); + Assert.equal(outPipeReadable.read(5), "abcde"); + + run_next_test(); +}); -- cgit v1.2.3