netwerk/test/unit/test_bug470716.js

   1 "use strict";
   2
   3 var CC = Components.Constructor;
   4
   5 const StreamCopier = CC(
   6   "@mozilla.org/network/async-stream-copier;1",
   7   "nsIAsyncStreamCopier",
   8   "init"
   9 );
  10
  11 const ScriptableInputStream = CC(
  12   "@mozilla.org/scriptableinputstream;1",
  13   "nsIScriptableInputStream",
  14   "init"
  15 );
  16
  17 const Pipe = CC("@mozilla.org/pipe;1", "nsIPipe", "init");
  18
  19 var pipe1;
  20 var pipe2;
  21 var copier;
  22 var test_result;
  23 var test_content;
  24 var test_source_closed;
  25 var test_sink_closed;
  26 var test_nr;
  27
  28 var copyObserver = {
  29   onStartRequest() {},
  30
  31   onStopRequest(request, statusCode) {
  32     // check status code
  33     Assert.equal(statusCode, test_result);
  34
  35     // check number of copied bytes
  36     Assert.equal(pipe2.inputStream.available(), test_content.length);
  37
  38     // check content
  39     var scinp = new ScriptableInputStream(pipe2.inputStream);
  40     var content = scinp.read(scinp.available());
  41     Assert.equal(content, test_content);
  42
  43     // check closed sink
  44     try {
  45       pipe2.outputStream.write("closedSinkTest", 14);
  46       Assert.ok(!test_sink_closed);
  47     } catch (ex) {
  48       Assert.ok(test_sink_closed);
  49     }
  50
  51     // check closed source
  52     try {
  53       pipe1.outputStream.write("closedSourceTest", 16);
  54       Assert.ok(!test_source_closed);
  55     } catch (ex) {
  56       Assert.ok(test_source_closed);
  57     }
  58
  59     do_timeout(0, do_test);
  60   },
  61
  62   QueryInterface: ChromeUtils.generateQI(["nsIRequestObserver"]),
  63 };
  64
  65 function startCopier(closeSource, closeSink) {
  66   pipe1 = new Pipe(
  67     true /* nonBlockingInput */,
  68     true /* nonBlockingOutput */,
  69     0 /* segmentSize */,
  70     0xffffffff /* segmentCount */,
  71     null /* segmentAllocator */
  72   );
  73
  74   pipe2 = new Pipe(
  75     true /* nonBlockingInput */,
  76     true /* nonBlockingOutput */,
  77     0 /* segmentSize */,
  78     0xffffffff /* segmentCount */,
  79     null /* segmentAllocator */
  80   );
  81
  82   copier = new StreamCopier(
  83     pipe1.inputStream /* aSource */,
  84     pipe2.outputStream /* aSink */,
  85     null /* aTarget */,
  86     true /* aSourceBuffered */,
  87     true /* aSinkBuffered */,
  88     8192 /* aChunkSize */,
  89     closeSource /* aCloseSource */,
  90     closeSink /* aCloseSink */
  91   );
  92
  93   copier.asyncCopy(copyObserver, null);
  94 }
  95
  96 function do_test() {
  97   test_nr++;
  98   test_content = "test" + test_nr;
  99
 100   switch (test_nr) {
 101     case 1:
 102     case 2: // close sink
 103     case 3: // close source
 104     case 4: // close both
 105       // test canceling transfer
 106       // use some undefined error code to check if it is successfully passed
 107       // to the request observer
 108       test_result = 0x87654321;
 109
 110       test_source_closed = (test_nr - 1) >> 1 != 0;
 111       test_sink_closed = (test_nr - 1) % 2 != 0;
 112
 113       startCopier(test_source_closed, test_sink_closed);
 114       pipe1.outputStream.write(test_content, test_content.length);
 115       pipe1.outputStream.flush();
 116       do_timeout(20, function () {
 117         copier.cancel(test_result);
 118         pipe1.outputStream.write("a", 1);
 119       });
 120       break;
 121     case 5:
 122     case 6: // close sink
 123     case 7: // close source
 124     case 8: // close both
 125       // test copying with EOF on source
 126       test_result = 0;
 127
 128       test_source_closed = (test_nr - 5) >> 1 != 0;
 129       test_sink_closed = (test_nr - 5) % 2 != 0;
 130
 131       startCopier(test_source_closed, test_sink_closed);
 132       pipe1.outputStream.write(test_content, test_content.length);
 133       // we will close the source
 134       test_source_closed = true;
 135       pipe1.outputStream.close();
 136       break;
 137     case 9:
 138     case 10: // close sink
 139     case 11: // close source
 140     case 12: // close both
 141       // test copying with error on sink
 142       // use some undefined error code to check if it is successfully passed
 143       // to the request observer
 144       test_result = 0x87654321;
 145
 146       test_source_closed = (test_nr - 9) >> 1 != 0;
 147       test_sink_closed = (test_nr - 9) % 2 != 0;
 148
 149       startCopier(test_source_closed, test_sink_closed);
 150       pipe1.outputStream.write(test_content, test_content.length);
 151       pipe1.outputStream.flush();
 152       // we will close the sink
 153       test_sink_closed = true;
 154       do_timeout(20, function () {
 155         pipe2.outputStream
 156           .QueryInterface(Ci.nsIAsyncOutputStream)
 157           .closeWithStatus(test_result);
 158         pipe1.outputStream.write("a", 1);
 159       });
 160       break;
 161     case 13:
 162       do_test_finished();
 163       break;
 164   }
 165 }
 166
 167 function run_test() {
 168   test_nr = 0;
 169   do_timeout(0, do_test);
 170   do_test_pending();
 171 }