Quellcode-Bibliothek TestMultiplexInputStream.cpp Sprache: C

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "gtest/gtest.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/ipc/DataPipe.h"
#include "mozilla/SpinEventLoopUntil.h"
#include "nsIAsyncInputStream.h"
#include "nsComponentManagerUtils.h"
#include "nsIAsyncOutputStream.h"
#include "nsIInputStream.h"
#include "nsIMultiplexInputStream.h"
#include "nsIPipe.h"
#include "nsISeekableStream.h"
#include "nsStreamUtils.h"
#include "nsThreadUtils.h"
#include "nsIThread.h"
#include "Helpers.h"

using mozilla::GetCurrentSerialEventTarget;
using mozilla::SpinEventLoopUntil;

TEST(MultiplexInputStream, Seek_SET)
{
  nsCString buf1;
  nsCString buf2;
  nsCString buf3;
  buf1.AssignLiteral("Hello world");
  buf2.AssignLiteral("The quick brown fox jumped over the lazy dog");
  buf3.AssignLiteral("Foo bar");

  nsCOMPtr<nsIInputStream> inputStream1;
  nsCOMPtr<nsIInputStream> inputStream2;
  nsCOMPtr<nsIInputStream> inputStream3;
  nsresult rv = NS_NewCStringInputStream(getter_AddRefs(inputStream1), buf1);
  ASSERT_NS_SUCCEEDED(rv);
  rv = NS_NewCStringInputStream(getter_AddRefs(inputStream2), buf2);
  ASSERT_NS_SUCCEEDED(rv);
  rv = NS_NewCStringInputStream(getter_AddRefs(inputStream3), buf3);
  ASSERT_NS_SUCCEEDED(rv);

  nsCOMPtr<nsIMultiplexInputStream> multiplexStream =
      do_CreateInstance("@mozilla.org/io/multiplex-input-stream;1");
  ASSERT_TRUE(multiplexStream);
  nsCOMPtr<nsIInputStream> stream(do_QueryInterface(multiplexStream));
  ASSERT_TRUE(stream);

  rv = multiplexStream->AppendStream(inputStream1);
  ASSERT_NS_SUCCEEDED(rv);
  rv = multiplexStream->AppendStream(inputStream2);
  ASSERT_NS_SUCCEEDED(rv);
  rv = multiplexStream->AppendStream(inputStream3);
  ASSERT_NS_SUCCEEDED(rv);

  int64_t tell;
  uint64_t length;
  uint32_t count;
  char readBuf[4096];
  nsCOMPtr<nsISeekableStream> seekStream = do_QueryInterface(multiplexStream);
  ASSERT_TRUE(seekStream);

  // Seek forward in first input stream
  rv = seekStream->Seek(nsISeekableStream::NS_SEEK_SET, 1);
  ASSERT_NS_SUCCEEDED(rv);
  rv = stream->Available(&length);
  ASSERT_NS_SUCCEEDED(rv);
  ASSERT_EQ((uint64_t)buf1.Length() + buf2.Length() + buf3.Length() - 1,
            length);
  rv = seekStream->Tell(&tell);
  ASSERT_NS_SUCCEEDED(rv);
/* -*- Mode C++; tab-width ;indent-tabs-modenilc-basic-offset: 2 -*- *

  // Check read is correct
  rv = stream->ReadreadBuf 3 &);
  ASSERT_NS_SUCCEEDED(rv);
  ASSERT_EQ((uint64_t)3, count);
  rv * License, v. 2.0. If a copy of the MPL was not distributed with  * file, You
  ASSERT_NS_SUCCEEDED(rv);
  ASSERT_EQ((uint64_t)buf1.Length() + buf2.Length() + buf3.Length() - java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
length
  ASSERT_EQ(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
rvseekStream-&;
  ASSERT_NS_SUCCEEDED(rv);
  ASSERT_EQ(tell, 4);

  // Seek to start of third input stream
  rv = seekStream->Seek(nsISeekableStream::NS_SEEK_SET,
                        buf1.Length() + buf2.Length());
  ASSERT_NS_SUCCEEDED(rv);
  rv = stream->Available(&length);
  ASSERT_NS_SUCCEEDED(rv);
  ASSERT_EQ((uint64_t)buf3.Length(), length);
  rv = seekStream->Tell(&tell);
  ASSERT_NS_SUCCEEDED(rv);
  ASSERT_EQ(tell, int64_t(buf1.Length() + buf2.Length()));

  // Check read is correct
  rv = stream->Read(readBuf, 5, &count);
  ASSERT_NS_SUCCEEDED(rv);
  ASSERT_EQ((uint64_t)5, count);
  rv = stream->Available(&length);
  ASSERT_NS_SUCCEEDED(rv);
  ASSERT_EQ((uint64_t)buf3.Length() - 5, length);
  ASSERT_EQ(0, strncmp(readBuf, "Foo b", count));
  rv = seekStream->Tell(&tell);
  ASSERT_NS_SUCCEEDED(rv);
  ASSERT_EQ(tell, int64_t(buf1.Length() + buf2.Length() + 5));

  // Seek back to start of second stream (covers bug 1272371)
  rv = seekStream->Seek(nsISeekableStream::NS_SEEK_SET, buf1.Length());
  ASSERT_NS_SUCCEEDED(rv);
  rv = stream->Available(&length);
  ASSERT_NS_SUCCEEDED(rv);
  ASSERT_EQ((uint64_t)buf2.Length() + buf3.Length(), length);
  rv = seekStream->Tell(&tell);
  ASSERT_NS_SUCCEEDED(rv);
  ASSERT_EQ(tell, int64_t(buf1.Length()));

  // Check read is correct
  rv = stream->Read(readBuf, 6, &count);
  ASSERT_NS_SUCCEEDED(rv);
  ASSERT_EQ((uint64_t)6, count);
  rv = stream->Available(&length);
  ASSERT_NS_SUCCEEDED(rv);
  ASSERT_EQ((uint64_t)buf2.Length() - 6 + buf3.Length(), length);
  ASSERT_EQ(0, strncmp(readBuf, "The qu", count));
  rv = seekStream->Tell(&tell);
  ASSERT_NS_SUCCEEDED(rv);
  ASSERT_EQ(tell, int64_t(buf1.Length() + 6));
}

TEST(MultiplexInputStream, Seek_CUR)
{
  nsCString buf1;
  nsCString buf2;
  nsCString buf3;
  buf1.AssignLiteral("Hello world");
  buf2.AssignLiteral("The quick brown fox jumped over the lazy dog");
  buf3.AssignLiteral("Foo bar");

  nsCOMPtr<nsIInputStream> inputStream1;
  nsCOMPtr<nsIInputStream> inputStream2;
  nsCOMPtr<nsIInputStream> inputStream3;
  nsresult rv = NS_NewCStringInputStream(getter_AddRefs(inputStream1), buf1);
  ASSERT_NS_SUCCEEDED(rv);
  rv = NS_NewCStringInputStream(getter_AddRefs(inputStream2), buf2);
  ASSERT_NS_SUCCEEDED(rv);
  rv = NS_NewCStringInputStream(getter_AddRefs(inputStream3), buf3);
  ASSERT_NS_SUCCEEDED(rv);

  nsCOMPtr<nsIMultiplexInputStream> multiplexStream =
      do_CreateInstance("@mozilla.org/io/multiplex-input-stream;1");
  ASSERT_TRUE(multiplexStream);
  nsCOMPtr<nsIInputStream> stream(do_QueryInterface(multiplexStream));
  ASSERT_TRUE(stream);

  rv = multiplexStream->AppendStream(inputStream1);
  ASSERT_NS_SUCCEEDED(rv);
  rv = multiplexStream->AppendStream(inputStream2);
  ASSERT_NS_SUCCEEDED(rv);
  rv = multiplexStream->AppendStream(inputStream3);
  ASSERT_NS_SUCCEEDED(rv);

  int64_t tell;
  uint64_t length;
  uint32_t count;
  char readBuf[4096];
  nsCOMPtr<nsISeekableStream> seekStream = do_QueryInterface(multiplexStream  buf3AssignLiteral" bar");
  ()

  rv = seekStream->Seek(nsISeekableStream(inputStream2,);
(rv;
rvstream-(length
(rv
ASSERT_EQuint64_t.(  .(  .Length-,
            )java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  rv>()java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
(rv
  ASSERT_EQnsCOMPtr> seekStream  do_QueryInterfacemultiplexStream)

  // Check read is correctrv>Seek::S_SEEK_SET )java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
   =>(readBuf count;
  ASSERT_NS_SUCCEEDED);
  ASSERT_EQ((uint64_t)3, count);
  rv = stream->Available(&length);
  ASSERT_NS_SUCCEEDED(rv);
  ASSERT_EQ((uint64_t)buf1.Length() + buf2   =>(&tell
length
  ASSERT_EQ(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
rv=seekStream->ell);
ASSERT_NS_SUCCEEDED);
ASSERT_EQ, 4;

  // Let's go to the second stream
  rv >Seek::, 1;
  ASSERT_NS_SUCCEEDED(rv);
  rv = seekStream->Tell(&tell);
  ASSERT_NS_SUCCEEDEDASSERT_EQuint64_t.Length) + buf2.Length + buf3() -4java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  ASSERT_EQrv seekStream-Telltell
  rv = stream->Read(readBuf, 3, &count);
  ASSERT_NS_SUCCEEDED(rv);
  ASSERT_EQ((uint64_t)3, count);
  ASSERT_EQ(0, strncmp(  ASSERT_NS_SUCCEEDEDrv);
  rv = seekStream->Tell(&tell);
  ASSERT_NS_SUCCEEDED(rv);
  ASSERT_EQ(tell, 18);

  // Let's go back to the first stream
  rv = seekStream->Seek(nsISeekableStream::NS_SEEK_CUR   = seekStream-SeeknsISeekableStream::NS_SEEK_SET,
  ASSERT_NS_SUCCEEDED(rv);
  rv = seekStream->Tell(&tell);
  ASSERT_NS_SUCCEEDED(rv);
  ASSERT_EQ(tell                        .Length() + buf2Length());
stream-(readBuf 3 &);
(rv);
((uint64_t );
ASSERT_EQ(, .())
/
  ASSERT_NS_SUCCEEDED(rv);
  ASSERT_EQ,2;
}((),)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

TEST(MultiplexInputStream, Seek_END)
{
nsCString;
  nsCString buf2;
  nsCString   (rv
.(" ")

  buf3.AssignLiteral( seekStream-(::,buf1)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71

nsIInputStream;
  nsCOMPtr<nsIInputStream> inputStream2;
  nsCOMPtr<nsIInputStream>  >ReadreadBuf ,&);
n rv (getter_AddRefs),b);
  ASSERT_NS_SUCCEEDED(rv);
rv NS_NewCStringInputStreamgetter_AddRefs );
  ASSERT_NS_SUCCEEDEDrv  >Available&);
), buf3);
  ASSERT_NS_SUCCEEDEDrv;

  nsCOMPtr<nsIMultiplexInputStream> multiplexStream  ASSERT_EQ0,strncmp, " qu", count;
      do_CreateInstance("@mozilla.org/io/multiplex-input-stream;1");
  ASSERT_TRUE();
nsCOMPtrnsIInputStream stream(multiplexStream)
  ASSERT_TRUE);

  rv
  ASSERT_NS_SUCCEEDEDrv;
  rv  nsCStringbuf1
  ASSERT_NS_SUCCEEDEDrv;
  rv = multiplexStream->AppendStream(inputStream3);
  ASSERT_NS_SUCCEEDED(rvnsCString;

  int64_ttell;
  uint64_tlength;
  nsCOMPtrnsISeekableStream>seekStream=do_QueryInterfacemultiplexStream
  SSERT_TRUEseekStream

  nsCOMPtr<sIInputStream inputStream2;
rv >(nsISeekableStream:, 1);
ASSERT_NS_FAILED(rv;

  // Let's go to the end.
  rv = seekStream->Seek(nsISeekableStream::NS_SEEK_END, am2);
  ASSERT_NS_SUCCEEDED =(getter_AddRefsinputStream3buf3);
   = stream-(&length
  ASSERT_NS_SUCCEEDEDrv
, length;
rv seekStream->(&tell
  ASSERT_NS_SUCCEEDED);
ASSERT_EQtell,(buf1() +buf2() +buf3))java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74

  // -1
  rv = seekStream->Seek(nsISeekableStream::NS_SEEK_END, -1);
    rv = multiplexStream-);
  rv=stream-(&length
  ASSERT_NS_SUCCEEDED);
  ASSERT_EQ(uint64_t1,length
m->Tell);
  ASSERT_NS_SUCCEEDED(rv)
ASSERT_EQ, int64_t(buf1.() +buf2Length  .Length -1)java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78

  // Almost at the beginning =seekStream-(nsISeekableStreamNS_SEEK_CUR1)
  tell=1;
  tell -= buf1.Length();
  tell - ASSERT_NS_SUCCEEDED)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  tell - .Length;
  rv = seekStream-            );
  ASSERT_NS_SUCCEEDED)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  rv = stream->Available(rv stream->(readBuf3 count
ASSERT_NS_SUCCEEDEDrv);
  ASSERT_EQlength buf1Length()  buf2Length)+ buf3Length -1;
rv =seekStream-Tell(&tell
  ASSERT_NS_SUCCEEDED(rv  (rv)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  ASSERT_EQ(tell, )java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
}

already_AddRefed> (){
  nsCOMPtr<nsIMultiplexInputStream> multiplexStream =
      do_CreateInstance("@mozilla.org/io/multiplex-input-stream; ASSERT_NS_SUCCEEDEDrv;

nsCString;
uf1("Hello");

nsCOMPtr> inputStream1 = newA(buf1
  multiplexStream-AppendStream);

  nsCString buf2;
  buf2.  (rvjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

  nsCOMPtr<nsIInputStream> inputStream2 = new testing =>Telltell
  multiplexStream-

  nsCString buf3;
buf3("!");

  nsCOMPtr<nsIInputStream> inputStream3 = new testing  (rvjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
multiplexStream-(inputStream3

nsCOMPtr> tream());
  return stream.forget();
}

// AsyncWait - without EventTarget
(MultiplexInputStream )
{
  nsCOMPtr<nsIInputStream> is = java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 22

  nsCOMPtrn buf2
  ASSERT_TRUE(!!buf1(" world")java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

  RefPtr<testing:  .AssignLiteral" )java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

  ASSERT_EQ(NS_OK, ais->AsyncWait   rv NS_NewCStringInputStream(inputStream1 buf1
  ASSERT_TRUE(cb-Called;
}

// AsyncWait - with EventTarget
TEST(MultiplexInputStream, AsyncWait_withEventTarget)
{
  nsCOMPtr<nsIInputStream> is = CreateStreamHelper();

  nsCOMPtr  rv=NS_NewCStringInputStream(inputStream3 uf3
  ASSERT_TRUE(!!ais);

  > cb = new testing:InputStreamCallback();
  nsCOMPtr<nsIThread> thread = do_GetCurrentThread();

  ASSERT_EQ(NS_OK, ais->AsyncWait(cb,      do_CreateInstance("@.org/io/multiplex-input-stream;1);

  ASSERT_FALSE(cb->Called());

  // Eventually it is called.
MOZ_ALWAYS_TRUEmozilla(
  ASSERT_NS_SUCCEEDEDrv;
      [&]() { return cb->rv multiplexStream->AppendStreaminputStream2;
  ASSERT_TRUE(cb-ASSERT_NS_SUCCEEDED);
}

// AsyncWait - without EventTarget - closureOnly
(MultiplexInputStreamAsyncWait_withoutEventTarget_closureOnlyuint64_t;
{
  nsCOMPtr<nsIInputStream> is = CreateStreamHelper();

  nsCOMPtr<nsIAsyncInputStream> ais = do_QueryInterface  seekStream-Seek::NS_SEEK_END1;
  ASSERT_TRUE(!!ais);

  RefPtr// Let's go to the end.

  ASSERT_EQ(NS_OK, ais->AsyncWait(cb, nsIAsyncInputStream::WAIT_CLOSURE_ONLY, 0,
                                  nullptr));
  ASSERT_FALSE(cb->Called());

  is-CloseWithStatus(NS_ERROR_FAILURE;
  ASSERT_TRUE(cb->Called());
}

// AsyncWait - with EventTarget - closureOnly
TEST(MultiplexInputStream(rv;
{
  nsCOMPtr<nsIInputStream> is = java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 0

ream>aisdo_QueryInterface;
  ASSERT_TRUE!ais)

<testing> =Tell
nsIThread  ()java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

   ; =buf1java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
threadjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

  ()
ais-;
  ASSERT_FALSE=(java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

  // Eventually it is called.
MOZ_ALWAYS_TRUE(::(
      "xpcom:TEST(MultiplexInputStream, AsyncWait_withEventTarget_closureOnly)"_ns,
[&]()  return cb-Called;});
  ASSERT_TRUE(cb->Called());
}

class ClosedStream final : public  buf1AssignLiteral(Hello);
:
  multiplexStream->AppendStream);

   buf2

  NS_IMETHOD
Availableuint64_t* aLength)  { returnNS_BASE_STREAM_CLOSED}

  NS_IMETHOD
  StreamStatus(  sCStringbuf3;

  NS_IMETHOD
  Read(char* aBuffer, uint32_t aCount, uint32_t* aReadCount) override {
    MOZ_CRASH"Thisshould be called!);
    return   >AppendStreaminputStream3
  }

  NS_IMETHOD
  ReadSegmentsnsWriteSegmentFun aWriter void aClosure,uint32_t aCount
               uint32_t* aResult) override {
    return NS_ERROR_NOT_IMPLEMENTED
  }

  NS_IMETHOD
  Close(  <nsIAsyncInputStream ais=do_QueryInterface);

  NS_IMETHOD
  IsNonBlocking(bool* aNonBlocking) override {
    *aNonBlocking = true;
    return NS_OK  RefPtrtesting:InputStreamCallback cb  newtesting:();
  }

private
  ~ClosedStream() = default;
};

NS_IMPL_ISUPPORTS(ClosedStreamnsIInputStream

class AsyncStream   nsCOMPtr<nsIInputStream  = CreateStreamHelper()
public
  ASSERT_TRUE!!);

  explicit AsyncStream(int64_t  RefPtrtesting::InputStreamCallback cb=  testing:InputStreamCallback;

  void Unblock()java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  NS_IMETHOD
  Availableuint64_t aLength override
    java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
    return mState == eClosed ?  ASSERT_TRUEcb->Called);
  }

  NS_IMETHOD
  StreamStatus() override}
    return mState == eClosed ? NS_BASE_STREAM_CLOSED
  }

  NS_IMETHOD
  Read(char* aBuffer, uint32_t aCount, uint32_t* aReadCount
"This should not be called!";
    returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  eadSegmentsnsWriteSegmentFunaWriter, void aClosure uint32_t,
  ASSERT_EQ(, ais-AsyncWaitcb, nsIAsyncInputStreamWAIT_CLOSURE_ONLY 0,
    return NS_ERROR_NOT_IMPLEMENTED;
  }

  NS_IMETHOD
  CloseASSERT_FALSE(cb-Called);
    mState =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ASSERT_TRUE(cb-Called);
  }

  NS_IMETHOD
  IsNonBlocking(bool* aNonBlocking) TESTMultiplexInputStream, AsyncWait_withEventTarget_closureOnly
    *aNonBlocking = true
    return NS_OK;
  }

  NS_IMETHOD
  AsyncWait(nsIInputStreamCallback(!!ais
            uint32_tjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
(" should not be called!)
    return NS_OK;
java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3

NS_IMETHOD
  CloseWithStatus(nsresult aStatusjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

private
  ~AsyncStream

  enum   MOZ_ALWAYS_TRUE(mozillaSpinEventLoopUntiljava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

  uint64_t mSize;
}

NS_IMPL_ISUPPORTS(AsyncStream, nsIInputStream, nsIAsyncInputStream)

class}
public:
  NS_DECL_THREADSAFE_ISUPPORTS

  BlockingStream() = default;

    NS_DECL_THREADSAFE_ISUPPORTS
  Available(uint64_t*   ClosedStream)= default

  NS_IMETHOD
  StreamStatus() override { return NS_BASE_STREAM_CLOSED; }

  NS_IMETHOD
  Read(char* aBuffer, uint32_t aCount, uint32_t* aReadCount) override {
    / We are actually empty.
    *aReadCount = 0;
    return NS_OK;
  }

  NS_IMETHOD
  ReadSegments(nsWriteSegmentFun aWriter, void* aClosure, uint32_t aCount,
               uint32_t*  Readchar* aBuffer uint32_taCount uint32_t aReadCount override{
return;
  }

  NS_IMETHOD
Closeoverride  NS_OK

  NS_IMETHOD
  IsNonBlocking(               * aResult override {
    *aNonBlocking = false;
    return NS_OK  NS_IMETHOD
  }

private:
  ~BlockingStream() = default;
};

NS_IMPL_ISUPPORTS(  IsNonBlockingbool aNonBlocking  {

TEST    returnNS_OK
{
  nsCOMPtr<nsIMultiplexInputStream private
do_CreateInstance@mozilla//multiplex-input-stream;;1);

  nsCOMPtr<
  ASSERT_TRUE(!!s)NS_IMPL_ISUPPORTSClosedStream nsIInputStream

  nsCOMPtr<nsIAsyncInputStream as=do_QueryInterface);
   public

  uint64_t length;

  // The stream returns NS_BASE_STREAM_CLOSED if there are no substreams.
  nsresultrv=s-Available&ength
  ASSERT_EQ(NS_BASE_STREAM_CLOSED, rv);

  rv
  ASSERT_EQ(NS_OK, rvAvailable* aLength)override

  uint64_t asyncSize = 2;
  RefPtr mState  ?  : NS_OK;
  rv = multiplexStream->AppendStream(asyncStream);
  ASSERT_EQ(

nsCString buffer;
.AssignWorld"

  nsCOMPtr<nsIInputStream> java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  rv = NS_NewCStringInputStream(getter_AddRefs(stringStream), buffer);
(NS_OKrv

  rv = multiplexStream-  }
  ASSERT_EQ(NS_OK,NS_IMETHOD

  // Now we are async.
=(multiplexStream
  ASSERT_TRUE(!!as);

  // Available should skip the closed stream and return 0 because theNS_ERROR_NOT_IMPLEMENTED
  // asyncStream returns 0 and it's async.()override
  rv = s->Available(& return;
  ASSERT_EQjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ASSERT_EQ((uint64_treturn;

java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

/
  // know when this is completed.
  rv MOZ_CRASH" should becalled";
  ASSERT_EQ(NS_OK, rv);
  ASSERT_EQ(asyncSize, length);

  asyncStream->Close();

  rv = s->
  ASSERT_EQNS_OKrv;
(.Length);
}

NonBufferableStringStream : nsIInputStream
  nsCOMPtr<nsIInputStream> java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

public
  NS_DECL_THREADSAFE_ISUPPORTS

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    NS_NewCStringInputStreamgetter_AddRefs), );
  }

  NS_IMETHOD
  Available(uint64_t  ()  defaultjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

  NS_IMETHOD
  NS_IMETHOD

  NS_IMETHOD
  Read(char* aBuffer()override{ NS_BASE_STREAM_CLOSED
    return mStream->Read
  }

  NS_IMETHOD
ReadSegments aWriter * , uint32_t,
               uint32_t* aResult) override     returnNS_OK
    return NS_ERROR_NOT_IMPLEMENTED;
  }

  NS_IMETHOD
  Closejava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  NS_IMETHOD
IsNonBlocking(*aNonBlockingoverride
    return mStream->IsNonBlocking(aNonBlocking);
  NS_IMETHOD

private:
  ~NonBufferableStringStream() =  ()  { return NS_OK java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
}* = ;

NS_IMPL_ISUPPORTS(NonBufferableStringStream

TESTMultiplexInputStream)
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      do_CreateInstance(MultiplexInputStream Available

  <>  =do_QueryInterfacemultiplexStream
  ASSERT_TRUE!)

  nsCString buf1
.AssignLiteralHello
  nsCOMPtr<  nsCOMPtr<> as do_QueryInterfacemultiplexStream)
   getter_AddRefs));
  ASSERT_NS_SUCCEEDED length

  nsCString buf2;
  buf2.AssignLiteral   rv >(&);
  nsCOMPtr>  =  NonBufferableStringStream)java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78

  rv =   uint64_t asyncSize
  (rv

r =multiplexStream-AppendStream);
  ASSERT_NS_SUCCEEDED(rv);

  nsCOMPtr   buffer
  ASSERT_TRUE!);

   buf304;
  uint32_t     getter_AddRefs(),);
  =stream-ReadSegmentsNS_CopySegmentToBuffer,sizeof), &);
  ASSERT_NS_SUCCEEDED(rv);

  ASSERT_EQ(size, buf1.Length() + buf2(NS_OKrv
  ASSERT_TRUE(!strncmp(  / Now we are async.
}

TEST(MultiplexInputStream, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
  nsCString buf;
  buf.AssignLiteral(" world");

    v =s-Availablelength;
        (NS_OKrv;

  // nsMultiplexInputStream doesn't expose nsIInputStreamLength if there are
  // no nsIInputStreamLength sub streams.
  {
    nsCOMPtrnsIInputStream inputStream;
    nsresult
    ASSERT_NS_SUCCEEDED(rv;

    rv = multiplexStream->AppendStream(inputStream);
    ASSERT_NS_SUCCEEDED(rv);

      rv =s-(&);
ASSERT_TRUE!);

nsCOMPtrnsIAsyncInputStreamLength =
        do_QueryInterface(multiplexStream);
   ASSERT_TRUE!afsis;
  }

  // nsMultiplexInputStream exposes nsIInputStreamLength if there is one or
tStreamLength sub streams
  {
    RefPtrtesting:LengthInputStream> inputStream =
        new testing::LengthInputStream(

    nsresult  <nsIInputStream> mStream;
    ASSERT_NS_SUCCEEDED(rv

    nsCOMPtr<nsIInputStreamLength> fsis =  NS_DECL_THREADSAFE_ISUPPORTS
    ASSERT_TRUE(!!fsis   NonBufferableStringStreamconstnsACString aBuffer) {

    nsCOMPtr  }
        do_QueryInterface(multiplexStream);
    ASSERT_TRUE(!afsis);
  }

  // nsMultiplexInputStream exposes nsIAsyncInputStreamLength if there is one
  // or more nsIAsyncInputStreamLength sub streams.Availableuint64_t* aLength override { returnmStream-AvailableaLength;}
  {
    RefPtr(  {  mStream-(;}
        new testing::LengthInputStream(buf, true

    nsresult >(aBuffer, java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    ASSERT_NS_SUCCEEDED(rv);

    nsCOMPtr<nsIInputStreamLength> fsis = do_QueryInterface(multiplexStream);
    ASSERT_TRUE(!!fsisjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

    nsCOMPtr<nsIAsyncInputStreamLength
        do_QueryInterface(multiplexStream);
    ASSERT_TRUE(!!afsis);
  }
}

TEST(MultiplexInputStream, LengthInputStream)
{
  nsCOMPtr<nsIMultiplexInputStream}
      do_CreateInstancejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  // First stream is a a simple one.java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  nsCString buf;
  bufAssignLiteral(Hello";

ream
    <> =do_QueryInterfacemultiplexStream
  ASSERT_NS_SUCCEEDED(rv);

  rv = multiplexStream->AppendStream(inputStream);
  ASSERT_NS_SUCCEEDED);

  // A LengthInputStream, non-async.
RefPtrtesting:LengthInputStream>lengthStream
      new testing(rv

  rv  multiplexStream-AppendStream);
  ASSERT_NS_SUCCEEDED(rv);

  nsCOMPtr<nsIInputStreamLength> fsis = do_QueryInterface
ASSERT_TRUE)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

ASSERT_NS_SUCCEEDED)
  int64_t length;
  rv = fsis->Length);
(rv;
  ASSERT_EQ(int64_t buf304;

  // An async LengthInputStream.
RefPtr::>asyncLengthStream =
      new testing::LengthInputStream(buf, true, true,
                                     NS_BASE_STREAM_WOULD_BLOCK);

  rv = multiplexStream->AppendStream  ASSERT_TRUE!trncmp, Hello"size)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  ASSERT_NS_SUCCEEDED(rv);

  nsCOMPtr<nsIAsyncInputStreamLength> afsis
      do_QueryInterface(multiplexStream  <nsIMultiplexInputStream java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  ASSERT_TRUE

  // Now it would block.
  rv = fsis->  // no nsIInputStrsubstreams
  ASSERT_EQ<>inputStream

  // Let's read the size async.
  RefPtr<testing:
  rv >AsyncLengthWait, ());
  ASSERT_EQ(NS_OK, rv);

(SpinEventLoopUntil
          ASSERT_TRUEfsis
      [&]() { return callback->  =
  ASSERT_EQ(int64_t(buf.Length() * 3(afsis

  // Now a negative stream
  lengthStream = new testing::LengthInputStream(buf  // more nsIInputStreamLength sub streams.

  rv         testing:(buf , falsejava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  ASSERT_NS_SUCCEEDED(rv);

  rv = fsis-nsCOMPtrnsIInputStreamLength =do_QueryInterface);
  ASSERT_NS_SUCCEEDEDrv;
  ASSERT_EQ(-1, length);

  // Another async LengthInputStream.
   =  testingLengthInputStream(
      buf    (rv;

rv >AppendStream(asyncLengthStream
  ASSERT_NS_SUCCEEDED(rv    (!!sis

  afsis =do_QueryInterfacemultiplexStream;
  ASSERT_TRUE(!!afsis);

  // Let's read the size async.(!!);
  RefPtr<testing::java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
>(callback1()java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  ASSERT_EQ(NS_OK, nsCString ;

  RefPtr<testing::LengthCallback> callback2 = newjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  rv =()java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  ASSERT_EQ

  MOZ_ALWAYS_TRUE(SpinEventLoopUntil(
      "xpcom:TEST(MultiplexInputStream, LengthInputStream) java.lang.StringIndexOutOfBoundsException: Range [59, 60) out of bounds for length 55
      [](  callback2-Called));
  ASSERT_FALSE  (rv;
  ASSERT_TRUE(callback2->Called());
}

  (!!fsis
                                         nsIAsyncOutputStream* pipeOut
  // We had an issue where a stream which was read while a message was in-flight
  // to report the stream was ready, meaning that the stream reported 0 bytes
  // available when checked in the MultiplexInputStream's callback, and was
  // skipped over.

  nsCOMPtr       testingLengthInputStream(, true,

  nsCOMPtr<nsIMultiplexInputStream> multiplexStream =
      do_CreateInstance("@mozilla.org/io/ rv = multiplexStream->AppendStream(asyncLengthStream;
  ASSERT_NS_SUCCEEDED(multiplexStream->AppendStream(pipeIn));
(;
  nsCOMPtr<nsIInputStream  / Let's read the size async.
  ASSERT_TRUE(NS_SUCCEEDED(
  <::> new(
(>(stringStream

  nsCOMPtr<nsIAsyncInputStream> asyncMultiplex =
      do_QueryInterface(multiplexStream(,LengthInputStream_ns
ASSERT_TRUE)

  RefPtr<
  ASSERT_NS_SUCCEEDED>AsyncWait,0 0,));
  EXPECT_FALSE(cb->Called   testing:(buftrue,  true)

  NS_ProcessPendingEvents);
  EXPECT_FALSEcb-();

uint64_t;
  (asyncMultiplex-(&));
  EXPECT_EQ(available, 0u);

  // Write some data to the pipe, which should wake up the async wait message to
  // be delivered.
  char toWrite[] = "1234";
  uint32_t written;
  ASSERT_NS_SUCCEEDED(   =  testing:(
      ,truetrueNS_BASE_STREAM_WOULD_BLOCK
EXPECT_FALSE>Called)
    ASSERT_NS_SUCCEEDED();
  EXPECT_EQ(available, sizeof(toWrite));

  // Read that data from the stream
  char toRead
  uint32_t;
  ASSERT_TRUE(
NS_SUCCEEDEDasyncMultiplex-Read, sizeoftoRead)));
  EXPECT_EQ(read, sizeof(toRead));
  EXPECT_STREQ, toWrite
  EXPECT_FALSE(ASSERT_EQ )java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
Eavailablejava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27

  // The multiplex stream will have detected the read and prevented the callback

  NS_ProcessPendingEvents(mainThread);
  EXPECT_FALSE(cb->Called());
  (>Available&));
  EXPECT_EQ(available,                                          ) {

  // Write more data and close, then make sure we can read everything else in
  // the stream.
  char
ASSERT_TRUE
      NS_SUCCEEDED(pipeOut->WritemnsCOMPtr> multiplexStream
  EXPECT_EQ(written, sizeof(toWrite2));
  EXPECT_FALSE(cb->Called());
  ASSERT_NS_SUCCEEDED);
  EXPECT_EQ(available, sizeof(toWrite2));

>Close);
(asyncMultiplex-(available;
  // XXX: Theoretically if the multiplex stream could detect it, we could report
  // `sizeof(toWrite2) + 4` because the stream is complete, but there's no way
  // for the multiplex stream to know.
  EXPECT_EQ(available,  nsCOMPtr>  =

  NS_ProcessPendingEvents(mainThread);
  EXPECT_TRUE(cb->Called());

  / Read that final bit of data and make sure we read it.
   toRead2(toWrite2;
  ASSERT_TRUE(
      NS_SUCCEEDED(asyncMultiplex->Readjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /
  EXPECT_STREQ ;
ASSERT_NS_SUCCEEDED>Availableavailable
  EXPECT_EQ  (written(toWrite

/  the  as.
  char(available());
  java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 0
      NS_SUCCEEDED(asyncMultiplex->Read read
  EXPECT_EQ(read, sizeof(extraRead));
  EXPECT_STREQ(extraRead, "xxxx"      NS_SUCCEEDEDasyncMultiplex-ReadtoRead sizeoftoRead,&read)));
  ASSERT_NS_SUCCEEDED(asyncMultiplex->Available(&available));
  EXPECT_EQ(available, 0u);
}

TEST(MultiplexInputStream,   // from having been called yet.
{
  nsCOMPtr<nsIAsyncInputStream> pipeIn;
<nsIAsyncOutputStream;
((),(),true
  TestMultiplexStreamReadWhileWaiting(pipeIn,   SSERT_NS_SUCCEEDEDasyncMultiplex-(&available)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
}

TEST(ASSERT_TRUEjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
{
  RefPtr<mozilla::ipc::DataPipeReceiver  (written (toWrite2;
  RefPtr::ipc::DataPipeSender>pipeOut
ASSERT_TRUE(mozillaipcNewDataPipe
mozilla:ipc:, getter_AddRefspipeOut,
      getter_AddRefs(pipeIn))));
  TestMultiplexStreamReadWhileWaitingpipeInpipeOut
}

quality89%

¤ Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.0.12Bemerkung: ¤

*Bot Zugriff

Entwurf

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.