netwerk/test/gtest/TestMIMEInputStream.cpp

   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 }