xpcom/tests/TestPipes.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   Pierre Phaneuf <pp@ludusdesign.com>
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either of the GNU General Public License Version 2 or later (the "GPL"),
  27  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 #include "TestHarness.h"
  40
  41 #include "nsIThread.h"
  42 #include "nsIRunnable.h"
  43 #include "nsThreadUtils.h"
  44 #include "prprf.h"
  45 #include "prinrval.h"
  46 #include "nsCRT.h"
  47 #include "nsIPipe.h"    // new implementation
  48 #include "nsAutoLock.h"
  49
  50
  51 /** NS_NewPipe2 reimplemented, because it's not exported by XPCOM */
  52 nsresult TP_NewPipe2(nsIAsyncInputStream** input,
  53                      nsIAsyncOutputStream** output,
  54                      PRBool nonBlockingInput,
  55                      PRBool nonBlockingOutput,
  56                      PRUint32 segmentSize,
  57                      PRUint32 segmentCount,
  58                      nsIMemory* segmentAlloc)
  59 {
  60   nsCOMPtr<nsIPipe> pipe = do_CreateInstance("@mozilla.org/pipe;1");
  61   if (!pipe)
  62     return NS_ERROR_OUT_OF_MEMORY;
  63
  64   nsresult rv = pipe->Init(nonBlockingInput,
  65                            nonBlockingOutput,
  66                            segmentSize,
  67                            segmentCount,
  68                            segmentAlloc);
  69
  70   if (NS_FAILED(rv))
  71     return rv;
  72
  73   pipe->GetInputStream(input);
  74   pipe->GetOutputStream(output);
  75   return NS_OK;
  76 }
  77
  78 /** NS_NewPipe reimplemented, because it's not exported by XPCOM */
  79 #define TP_DEFAULT_SEGMENT_SIZE  4096
  80 nsresult TP_NewPipe(nsIInputStream **pipeIn,
  81                     nsIOutputStream **pipeOut,
  82                     PRUint32 segmentSize = 0,
  83                     PRUint32 maxSize = 0,
  84                     PRBool nonBlockingInput = PR_FALSE,
  85                     PRBool nonBlockingOutput = PR_FALSE,
  86                     nsIMemory *segmentAlloc = nsnull);
  87 nsresult TP_NewPipe(nsIInputStream **pipeIn,
  88                     nsIOutputStream **pipeOut,
  89                     PRUint32 segmentSize,
  90                     PRUint32 maxSize,
  91                     PRBool nonBlockingInput,
  92                     PRBool nonBlockingOutput,
  93                     nsIMemory *segmentAlloc)
  94 {
  95     if (segmentSize == 0)
  96         segmentSize = TP_DEFAULT_SEGMENT_SIZE;
  97
  98     // Handle maxSize of PR_UINT32_MAX as a special case
  99     PRUint32 segmentCount;
 100     if (maxSize == PR_UINT32_MAX)
 101         segmentCount = PR_UINT32_MAX;
 102     else
 103         segmentCount = maxSize / segmentSize;
 104
 105     nsIAsyncInputStream *in;
 106     nsIAsyncOutputStream *out;
 107     nsresult rv = TP_NewPipe2(&in, &out, nonBlockingInput, nonBlockingOutput,
 108                               segmentSize, segmentCount, segmentAlloc);
 109     if (NS_FAILED(rv)) return rv;
 110
 111     *pipeIn = in;
 112     *pipeOut = out;
 113     return NS_OK;
 114 }
 115
 116
 117 #define KEY             0xa7
 118 #define ITERATIONS      33333
 119 char kTestPattern[] = "My hovercraft is full of eels.\n";
 120
 121 PRBool gTrace = PR_FALSE;
 122
 123 static nsresult
 124 WriteAll(nsIOutputStream *os, const char *buf, PRUint32 bufLen, PRUint32 *lenWritten)
 125 {
 126     const char *p = buf;
 127     *lenWritten = 0;
 128     while (bufLen) {
 129         PRUint32 n;
 130         nsresult rv = os->Write(p, bufLen, &n);
 131         if (NS_FAILED(rv)) return rv;
 132         p += n;
 133         bufLen -= n;
 134         *lenWritten += n;
 135     }
 136     return NS_OK;
 137 }
 138
 139 class nsReceiver : public nsIRunnable {
 140 public:
 141     NS_DECL_ISUPPORTS
 142
 143     NS_IMETHOD Run() {
 144         nsresult rv;
 145         char buf[101];
 146         PRUint32 count;
 147         PRIntervalTime start = PR_IntervalNow();
 148         while (PR_TRUE) {
 149             rv = mIn->Read(buf, 100, &count);
 150             if (NS_FAILED(rv)) {
 151                 printf("read failed\n");
 152                 break;
 153             }
 154             if (count == 0) {
 155 //                printf("EOF count = %d\n", mCount);
 156                 break;
 157             }
 158
 159             if (gTrace) {
 160                 buf[count] = '\0';
 161                 printf("read: %s\n", buf);
 162             }
 163             mCount += count;
 164         }
 165         PRIntervalTime end = PR_IntervalNow();
 166         printf("read  %d bytes, time = %dms\n", mCount,
 167                PR_IntervalToMilliseconds(end - start));
 168         return rv;
 169     }
 170
 171     nsReceiver(nsIInputStream* in) : mIn(in), mCount(0) {
 172     }
 173
 174     PRUint32 GetBytesRead() { return mCount; }
 175
 176 protected:
 177     nsCOMPtr<nsIInputStream> mIn;
 178     PRUint32            mCount;
 179 };
 180
 181 NS_IMPL_THREADSAFE_ISUPPORTS1(nsReceiver, nsIRunnable)
 182
 183 nsresult
 184 TestPipe(nsIInputStream* in, nsIOutputStream* out)
 185 {
 186     nsCOMPtr<nsReceiver> receiver = new nsReceiver(in);
 187     if (!receiver)
 188         return NS_ERROR_OUT_OF_MEMORY;
 189
 190     nsresult rv;
 191
 192     nsCOMPtr<nsIThread> thread;
 193     rv = NS_NewThread(getter_AddRefs(thread), receiver);
 194     if (NS_FAILED(rv)) return rv;
 195
 196     PRUint32 total = 0;
 197     PRIntervalTime start = PR_IntervalNow();
 198     for (PRUint32 i = 0; i < ITERATIONS; i++) {
 199         PRUint32 writeCount;
 200         char *buf = PR_smprintf("%d %s", i, kTestPattern);
 201         PRUint32 len = strlen(buf);
 202         rv = WriteAll(out, buf, len, &writeCount);
 203         if (gTrace) {
 204             printf("wrote: ");
 205             for (PRUint32 j = 0; j < writeCount; j++) {
 206                 putc(buf[j], stdout);
 207             }
 208             printf("\n");
 209         }
 210         PR_smprintf_free(buf);
 211         if (NS_FAILED(rv)) return rv;
 212         total += writeCount;
 213     }
 214     rv = out->Close();
 215     if (NS_FAILED(rv)) return rv;
 216
 217     PRIntervalTime end = PR_IntervalNow();
 218
 219     thread->Shutdown();
 220
 221     printf("wrote %d bytes, time = %dms\n", total,
 222            PR_IntervalToMilliseconds(end - start));
 223     NS_ASSERTION(receiver->GetBytesRead() == total, "didn't read everything");
 224
 225     return NS_OK;
 226 }
 227
 228 ////////////////////////////////////////////////////////////////////////////////
 229
 230 class nsShortReader : public nsIRunnable {
 231 public:
 232     NS_DECL_ISUPPORTS
 233
 234     NS_IMETHOD Run() {
 235         nsresult rv;
 236         char buf[101];
 237         PRUint32 count;
 238         PRUint32 total = 0;
 239         while (PR_TRUE) {
 240             //if (gTrace)
 241             //    printf("calling Read\n");
 242             rv = mIn->Read(buf, 100, &count);
 243             if (NS_FAILED(rv)) {
 244                 printf("read failed\n");
 245                 break;
 246             }
 247             if (count == 0) {
 248                 break;
 249             }
 250
 251             if (gTrace) {
 252                 // For next |printf()| call and possible others elsewhere.
 253                 buf[count] = '\0';
 254
 255                 printf("read %d bytes: %s\n", count, buf);
 256             }
 257
 258             Received(count);
 259             total += count;
 260         }
 261         printf("read  %d bytes\n", total);
 262         return rv;
 263     }
 264
 265     nsShortReader(nsIInputStream* in) : mIn(in), mReceived(0) {
 266     }
 267
 268     void Received(PRUint32 count) {
 269         nsAutoCMonitor mon(this);
 270         mReceived += count;
 271         mon.Notify();
 272     }
 273
 274     PRUint32 WaitForReceipt(const PRUint32 aWriteCount) {
 275         nsAutoCMonitor mon(this);
 276         PRUint32 result = mReceived;
 277
 278         while (result < aWriteCount) {
 279             mon.Wait();
 280
 281             NS_ASSERTION(mReceived > result, "failed to receive");
 282             result = mReceived;
 283         }
 284
 285         mReceived = 0;
 286         return result;
 287     }
 288
 289 protected:
 290     nsCOMPtr<nsIInputStream> mIn;
 291     PRUint32            mReceived;
 292 };
 293
 294 NS_IMPL_THREADSAFE_ISUPPORTS1(nsShortReader, nsIRunnable)
 295
 296 nsresult
 297 TestShortWrites(nsIInputStream* in, nsIOutputStream* out)
 298 {
 299     nsCOMPtr<nsShortReader> receiver = new nsShortReader(in);
 300     if (!receiver)
 301         return NS_ERROR_OUT_OF_MEMORY;
 302
 303     nsresult rv;
 304
 305     nsCOMPtr<nsIThread> thread;
 306     rv = NS_NewThread(getter_AddRefs(thread), receiver);
 307     if (NS_FAILED(rv)) return rv;
 308
 309     PRUint32 total = 0;
 310     for (PRUint32 i = 0; i < ITERATIONS; i++) {
 311         PRUint32 writeCount;
 312         char* buf = PR_smprintf("%d %s", i, kTestPattern);
 313         PRUint32 len = strlen(buf);
 314         len = len * rand() / RAND_MAX;
 315         len = PR_MAX(1, len);
 316         rv = WriteAll(out, buf, len, &writeCount);
 317         if (NS_FAILED(rv)) return rv;
 318         NS_ASSERTION(writeCount == len, "didn't write enough");
 319         total += writeCount;
 320
 321         if (gTrace)
 322             printf("wrote %d bytes: %s\n", writeCount, buf);
 323         PR_smprintf_free(buf);
 324         //printf("calling Flush\n");
 325         out->Flush();
 326         //printf("calling WaitForReceipt\n");
 327         const PRUint32 received = receiver->WaitForReceipt(writeCount);
 328         NS_ASSERTION(received == writeCount, "received wrong amount");
 329     }
 330     rv = out->Close();
 331     if (NS_FAILED(rv)) return rv;
 332
 333     thread->Shutdown();
 334
 335     printf("wrote %d bytes\n", total);
 336
 337     return NS_OK;
 338 }
 339
 340 ////////////////////////////////////////////////////////////////////////////////
 341
 342 class nsPump : public nsIRunnable
 343 {
 344 public:
 345     NS_DECL_ISUPPORTS
 346
 347     NS_IMETHOD Run() {
 348         nsresult rv;
 349         PRUint32 count;
 350         while (PR_TRUE) {
 351             rv = mOut->WriteFrom(mIn, ~0U, &count);
 352             if (NS_FAILED(rv)) {
 353                 printf("Write failed\n");
 354                 break;
 355             }
 356             if (count == 0) {
 357                 printf("EOF count = %d\n", mCount);
 358                 break;
 359             }
 360
 361             if (gTrace) {
 362                 printf("Wrote: %d\n", count);
 363             }
 364             mCount += count;
 365         }
 366         mOut->Close();
 367         return rv;
 368     }
 369
 370     nsPump(nsIInputStream* in,
 371            nsIOutputStream* out)
 372         : mIn(in), mOut(out), mCount(0) {
 373     }
 374
 375 protected:
 376     nsCOMPtr<nsIInputStream>      mIn;
 377     nsCOMPtr<nsIOutputStream>     mOut;
 378     PRUint32                            mCount;
 379 };
 380
 381 NS_IMPL_THREADSAFE_ISUPPORTS1(nsPump,
 382                               nsIRunnable)
 383
 384 nsresult
 385 TestChainedPipes()
 386 {
 387     nsresult rv;
 388     printf("TestChainedPipes\n");
 389
 390     nsCOMPtr<nsIInputStream> in1;
 391     nsCOMPtr<nsIOutputStream> out1;
 392     rv = TP_NewPipe(getter_AddRefs(in1), getter_AddRefs(out1), 20, 1999);
 393     if (NS_FAILED(rv)) return rv;
 394
 395     nsCOMPtr<nsIInputStream> in2;
 396     nsCOMPtr<nsIOutputStream> out2;
 397     rv = TP_NewPipe(getter_AddRefs(in2), getter_AddRefs(out2), 200, 401);
 398     if (NS_FAILED(rv)) return rv;
 399
 400     nsCOMPtr<nsPump> pump = new nsPump(in1, out2);
 401     if (pump == nsnull) return NS_ERROR_OUT_OF_MEMORY;
 402
 403     nsCOMPtr<nsIThread> thread;
 404     rv = NS_NewThread(getter_AddRefs(thread), pump);
 405     if (NS_FAILED(rv)) return rv;
 406
 407     nsCOMPtr<nsReceiver> receiver = new nsReceiver(in2);
 408     if (receiver == nsnull) return NS_ERROR_OUT_OF_MEMORY;
 409
 410     nsCOMPtr<nsIThread> receiverThread;
 411     rv = NS_NewThread(getter_AddRefs(receiverThread), receiver);
 412     if (NS_FAILED(rv)) return rv;
 413
 414     PRUint32 total = 0;
 415     for (PRUint32 i = 0; i < ITERATIONS; i++) {
 416         PRUint32 writeCount;
 417         char* buf = PR_smprintf("%d %s", i, kTestPattern);
 418         PRUint32 len = strlen(buf);
 419         len = len * rand() / RAND_MAX;
 420         len = PR_MAX(1, len);
 421         rv = WriteAll(out1, buf, len, &writeCount);
 422         if (NS_FAILED(rv)) return rv;
 423         NS_ASSERTION(writeCount == len, "didn't write enough");
 424         total += writeCount;
 425
 426         if (gTrace)
 427             printf("wrote %d bytes: %s\n", writeCount, buf);
 428
 429         PR_smprintf_free(buf);
 430     }
 431     printf("wrote total of %d bytes\n", total);
 432     rv = out1->Close();
 433     if (NS_FAILED(rv)) return rv;
 434
 435     thread->Shutdown();
 436     receiverThread->Shutdown();
 437
 438     return NS_OK;
 439 }
 440
 441 ////////////////////////////////////////////////////////////////////////////////
 442
 443 void
 444 RunTests(PRUint32 segSize, PRUint32 segCount)
 445 {
 446     nsresult rv;
 447     nsCOMPtr<nsIInputStream> in;
 448     nsCOMPtr<nsIOutputStream> out;
 449     PRUint32 bufSize = segSize * segCount;
 450     printf("Testing New Pipes: segment size %d buffer size %d\n", segSize, bufSize);
 451
 452     printf("Testing long writes...\n");
 453     rv = TP_NewPipe(getter_AddRefs(in), getter_AddRefs(out), segSize, bufSize);
 454     NS_ASSERTION(NS_SUCCEEDED(rv), "TP_NewPipe failed");
 455     rv = TestPipe(in, out);
 456     NS_ASSERTION(NS_SUCCEEDED(rv), "TestPipe failed");
 457
 458     printf("Testing short writes...\n");
 459     rv = TP_NewPipe(getter_AddRefs(in), getter_AddRefs(out), segSize, bufSize);
 460     NS_ASSERTION(NS_SUCCEEDED(rv), "TP_NewPipe failed");
 461     rv = TestShortWrites(in, out);
 462     NS_ASSERTION(NS_SUCCEEDED(rv), "TestPipe failed");
 463 }
 464
 465 ////////////////////////////////////////////////////////////////////////////////
 466
 467 #if !defined(MOZ_ENABLE_LIBXUL) && defined(DEBUG)
 468 extern NS_COM void
 469 TestSegmentedBuffer();
 470 #endif
 471
 472 int
 473 main(int argc, char* argv[])
 474 {
 475     nsresult rv;
 476
 477     nsCOMPtr<nsIServiceManager> servMgr;
 478     rv = NS_InitXPCOM2(getter_AddRefs(servMgr), NULL, NULL);
 479     if (NS_FAILED(rv)) return rv;
 480
 481     if (argc > 1 && nsCRT::strcmp(argv[1], "-trace") == 0)
 482         gTrace = PR_TRUE;
 483
 484 #if !defined(MOZ_ENABLE_LIBXUL) && defined(DEBUG)
 485     printf("Testing segmented buffer...\n");
 486     TestSegmentedBuffer();
 487 #endif
 488
 489     rv = TestChainedPipes();
 490     NS_ASSERTION(NS_SUCCEEDED(rv), "TestChainedPipes failed");
 491     RunTests(16, 1);
 492     RunTests(4096, 16);
 493
 494     servMgr = 0;
 495     rv = NS_ShutdownXPCOM( NULL );
 496     NS_ASSERTION(NS_SUCCEEDED(rv), "NS_ShutdownXPCOM failed");
 497
 498     return 0;
 499 }
 500
 501 ////////////////////////////////////////////////////////////////////////////////