tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

TestMIMEInputStream.cpp (7067B)

      1 #include "gtest/gtest.h"
      2 
      3 #include "Helpers.h"
      4 #include "mozilla/SpinEventLoopUntil.h"
      5 #include "nsComponentManagerUtils.h"
      6 #include "nsCOMPtr.h"
      7 #include "nsStreamUtils.h"
      8 #include "nsString.h"
      9 #include "nsStringStream.h"
     10 #include "nsIMIMEInputStream.h"
     11 #include "nsISeekableStream.h"
     12 
     13 using mozilla::GetCurrentSerialEventTarget;
     14 using mozilla::SpinEventLoopUntil;
     15 
     16 namespace {
     17 
     18 class SeekableLengthInputStream final : public testing::LengthInputStream,
     19                                        public nsISeekableStream {
     20 public:
     21  SeekableLengthInputStream(const nsACString& aBuffer,
     22                            bool aIsInputStreamLength,
     23                            bool aIsAsyncInputStreamLength,
     24                            nsresult aLengthRv = NS_OK,
     25                            bool aNegativeValue = false)
     26      : testing::LengthInputStream(aBuffer, aIsInputStreamLength,
     27                                   aIsAsyncInputStreamLength, aLengthRv,
     28                                   aNegativeValue) {}
     29 
     30  NS_DECL_ISUPPORTS_INHERITED
     31 
     32  NS_IMETHOD
     33  Seek(int32_t aWhence, int64_t aOffset) override {
     34    MOZ_CRASH("This method should not be called.");
     35    return NS_ERROR_FAILURE;
     36  }
     37 
     38  NS_IMETHOD
     39  Tell(int64_t* aResult) override {
     40    MOZ_CRASH("This method should not be called.");
     41    return NS_ERROR_FAILURE;
     42  }
     43 
     44  NS_IMETHOD
     45  SetEOF() override {
     46    MOZ_CRASH("This method should not be called.");
     47    return NS_ERROR_FAILURE;
     48  }
     49 
     50 private:
     51  ~SeekableLengthInputStream() = default;
     52 };
     53 
     54 NS_IMPL_ISUPPORTS_INHERITED(SeekableLengthInputStream,
     55                            testing::LengthInputStream, nsISeekableStream)
     56 
     57 }  // namespace
     58 
     59 // nsIInputStreamLength && nsIAsyncInputStreamLength
     60 
     61 TEST(TestNsMIMEInputStream, QIInputStreamLength)
     62 {
     63  nsCString buf;
     64  buf.AssignLiteral("Hello world");
     65 
     66  for (int i = 0; i < 4; i++) {
     67    nsCOMPtr<nsIInputStream> mis;
     68    {
     69      RefPtr<SeekableLengthInputStream> stream =
     70          new SeekableLengthInputStream(buf, i % 2, i > 1);
     71 
     72      nsresult rv;
     73      nsCOMPtr<nsIMIMEInputStream> m(
     74          do_CreateInstance("@mozilla.org/network/mime-input-stream;1", &rv));
     75      ASSERT_EQ(NS_OK, rv);
     76 
     77      rv = m->SetData(stream);
     78      ASSERT_EQ(NS_OK, rv);
     79 
     80      mis = m;
     81      ASSERT_TRUE(!!mis);
     82    }
     83 
     84    {
     85      nsCOMPtr<nsIInputStreamLength> qi = do_QueryInterface(mis);
     86      ASSERT_EQ(!!(i % 2), !!qi);
     87    }
     88 
     89    {
     90      nsCOMPtr<nsIAsyncInputStreamLength> qi = do_QueryInterface(mis);
     91      ASSERT_EQ(i > 1, !!qi);
     92    }
     93  }
     94 }
     95 
     96 TEST(TestNsMIMEInputStream, InputStreamLength)
     97 {
     98  nsCString buf;
     99  buf.AssignLiteral("Hello world");
    100 
    101  nsCOMPtr<nsIInputStream> mis;
    102  {
    103    RefPtr<SeekableLengthInputStream> stream =
    104        new SeekableLengthInputStream(buf, true, false);
    105 
    106    nsresult rv;
    107    nsCOMPtr<nsIMIMEInputStream> m(
    108        do_CreateInstance("@mozilla.org/network/mime-input-stream;1", &rv));
    109    ASSERT_EQ(NS_OK, rv);
    110 
    111    rv = m->SetData(stream);
    112    ASSERT_EQ(NS_OK, rv);
    113 
    114    mis = m;
    115    ASSERT_TRUE(!!mis);
    116  }
    117 
    118  nsCOMPtr<nsIInputStreamLength> qi = do_QueryInterface(mis);
    119  ASSERT_TRUE(!!qi);
    120 
    121  int64_t size;
    122  nsresult rv = qi->Length(&size);
    123  ASSERT_EQ(NS_OK, rv);
    124  ASSERT_EQ(int64_t(buf.Length()), size);
    125 }
    126 
    127 TEST(TestNsMIMEInputStream, NegativeInputStreamLength)
    128 {
    129  nsCString buf;
    130  buf.AssignLiteral("Hello world");
    131 
    132  nsCOMPtr<nsIInputStream> mis;
    133  {
    134    RefPtr<SeekableLengthInputStream> stream =
    135        new SeekableLengthInputStream(buf, true, false, NS_OK, true);
    136 
    137    nsresult rv;
    138    nsCOMPtr<nsIMIMEInputStream> m(
    139        do_CreateInstance("@mozilla.org/network/mime-input-stream;1", &rv));
    140    ASSERT_EQ(NS_OK, rv);
    141 
    142    rv = m->SetData(stream);
    143    ASSERT_EQ(NS_OK, rv);
    144 
    145    mis = m;
    146    ASSERT_TRUE(!!mis);
    147  }
    148 
    149  nsCOMPtr<nsIInputStreamLength> qi = do_QueryInterface(mis);
    150  ASSERT_TRUE(!!qi);
    151 
    152  int64_t size;
    153  nsresult rv = qi->Length(&size);
    154  ASSERT_EQ(NS_OK, rv);
    155  ASSERT_EQ(-1, size);
    156 }
    157 
    158 TEST(TestNsMIMEInputStream, AsyncInputStreamLength)
    159 {
    160  nsCString buf;
    161  buf.AssignLiteral("Hello world");
    162 
    163  nsCOMPtr<nsIInputStream> mis;
    164  {
    165    RefPtr<SeekableLengthInputStream> stream =
    166        new SeekableLengthInputStream(buf, false, true);
    167 
    168    nsresult rv;
    169    nsCOMPtr<nsIMIMEInputStream> m(
    170        do_CreateInstance("@mozilla.org/network/mime-input-stream;1", &rv));
    171    ASSERT_EQ(NS_OK, rv);
    172 
    173    rv = m->SetData(stream);
    174    ASSERT_EQ(NS_OK, rv);
    175 
    176    mis = m;
    177    ASSERT_TRUE(!!mis);
    178  }
    179 
    180  nsCOMPtr<nsIAsyncInputStreamLength> qi = do_QueryInterface(mis);
    181  ASSERT_TRUE(!!qi);
    182 
    183  RefPtr<testing::LengthCallback> callback = new testing::LengthCallback();
    184 
    185  nsresult rv = qi->AsyncLengthWait(callback, GetCurrentSerialEventTarget());
    186  ASSERT_EQ(NS_OK, rv);
    187 
    188  MOZ_ALWAYS_TRUE(SpinEventLoopUntil(
    189      "TEST(TestNsMIMEInputStream, AsyncInputStreamLength)"_ns,
    190      [&]() { return callback->Called(); }));
    191  ASSERT_EQ(int64_t(buf.Length()), callback->Size());
    192 }
    193 
    194 TEST(TestNsMIMEInputStream, NegativeAsyncInputStreamLength)
    195 {
    196  nsCString buf;
    197  buf.AssignLiteral("Hello world");
    198 
    199  nsCOMPtr<nsIInputStream> mis;
    200  {
    201    RefPtr<SeekableLengthInputStream> stream =
    202        new SeekableLengthInputStream(buf, false, true, NS_OK, true);
    203 
    204    nsresult rv;
    205    nsCOMPtr<nsIMIMEInputStream> m(
    206        do_CreateInstance("@mozilla.org/network/mime-input-stream;1", &rv));
    207    ASSERT_EQ(NS_OK, rv);
    208 
    209    rv = m->SetData(stream);
    210    ASSERT_EQ(NS_OK, rv);
    211 
    212    mis = m;
    213    ASSERT_TRUE(!!mis);
    214  }
    215 
    216  nsCOMPtr<nsIAsyncInputStreamLength> qi = do_QueryInterface(mis);
    217  ASSERT_TRUE(!!qi);
    218 
    219  RefPtr<testing::LengthCallback> callback = new testing::LengthCallback();
    220 
    221  nsresult rv = qi->AsyncLengthWait(callback, GetCurrentSerialEventTarget());
    222  ASSERT_EQ(NS_OK, rv);
    223 
    224  MOZ_ALWAYS_TRUE(SpinEventLoopUntil(
    225      "TEST(TestNsMIMEInputStream, NegativeAsyncInputStreamLength)"_ns,
    226      [&]() { return callback->Called(); }));
    227  ASSERT_EQ(-1, callback->Size());
    228 }
    229 
    230 TEST(TestNsMIMEInputStream, AbortLengthCallback)
    231 {
    232  nsCString buf;
    233  buf.AssignLiteral("Hello world");
    234 
    235  nsCOMPtr<nsIInputStream> mis;
    236  {
    237    RefPtr<SeekableLengthInputStream> stream =
    238        new SeekableLengthInputStream(buf, false, true, NS_OK, true);
    239 
    240    nsresult rv;
    241    nsCOMPtr<nsIMIMEInputStream> m(
    242        do_CreateInstance("@mozilla.org/network/mime-input-stream;1", &rv));
    243    ASSERT_EQ(NS_OK, rv);
    244 
    245    rv = m->SetData(stream);
    246    ASSERT_EQ(NS_OK, rv);
    247 
    248    mis = m;
    249    ASSERT_TRUE(!!mis);
    250  }
    251 
    252  nsCOMPtr<nsIAsyncInputStreamLength> qi = do_QueryInterface(mis);
    253  ASSERT_TRUE(!!qi);
    254 
    255  RefPtr<testing::LengthCallback> callback1 = new testing::LengthCallback();
    256  nsresult rv = qi->AsyncLengthWait(callback1, GetCurrentSerialEventTarget());
    257  ASSERT_EQ(NS_OK, rv);
    258 
    259  RefPtr<testing::LengthCallback> callback2 = new testing::LengthCallback();
    260  rv = qi->AsyncLengthWait(callback2, GetCurrentSerialEventTarget());
    261  ASSERT_EQ(NS_OK, rv);
    262 
    263  MOZ_ALWAYS_TRUE(
    264      SpinEventLoopUntil("TEST(TestNsMIMEInputStream, AbortLengthCallback)"_ns,
    265                         [&]() { return callback2->Called(); }));
    266  ASSERT_TRUE(!callback1->Called());
    267  ASSERT_EQ(-1, callback2->Size());
    268 }