startupcache/test/TestStartupCache.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2; -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "gtest/gtest.h"
   7
   8 #include "mozilla/scache/StartupCache.h"
   9 #include "mozilla/scache/StartupCacheUtils.h"
  10
  11 #include "nsDirectoryServiceDefs.h"
  12 #include "nsIOutputStream.h"
  13 #include "nsISupports.h"
  14 #include "nsIStorageStream.h"
  15 #include "nsIObjectInputStream.h"
  16 #include "nsIObjectOutputStream.h"
  17 #include "nsIURI.h"
  18 #include "nsThreadUtils.h"
  19 #include "prenv.h"
  20 #include "prio.h"
  21 #include "prprf.h"
  22 #include "mozilla/gtest/MozAssertions.h"
  23 #include "mozilla/Maybe.h"
  24 #include "mozilla/Printf.h"
  25 #include "mozilla/UniquePtr.h"
  26 #include "mozilla/UniquePtrExtensions.h"
  27 #include "nsNetCID.h"
  28 #include "nsIURIMutator.h"
  29
  30 using namespace JS;
  31
  32 using namespace mozilla::scache;
  33 using mozilla::UniquePtr;
  34
  35 void WaitForStartupTimer() {
  36   StartupCache* sc = StartupCache::GetSingleton();
  37   PR_Sleep(3 * PR_TicksPerSecond());
  38
  39   while (true) {
  40     NS_ProcessPendingEvents(nullptr);
  41     if (sc->StartupWriteComplete()) {
  42       return;
  43     }
  44     PR_Sleep(1 * PR_TicksPerSecond());
  45   }
  46 }
  47
  48 class TestStartupCache : public ::testing::Test {
  49  protected:
  50   TestStartupCache();
  51   ~TestStartupCache();
  52
  53   nsCOMPtr<nsIFile> mSCFile;
  54 };
  55
  56 TestStartupCache::TestStartupCache() {
  57   NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(mSCFile));
  58   mSCFile->AppendNative("test-startupcache.tmp"_ns);
  59 #ifdef XP_WIN
  60   nsAutoString env(u"MOZ_STARTUP_CACHE="_ns);
  61   env.Append(mSCFile->NativePath());
  62   _wputenv(env.get());
  63 #else
  64   nsAutoCString path;
  65   mSCFile->GetNativePath(path);
  66   char* env = mozilla::Smprintf("MOZ_STARTUP_CACHE=%s", path.get()).release();
  67   PR_SetEnv(env);
  68   // We intentionally leak `env` here because it is required by PR_SetEnv
  69   MOZ_LSAN_INTENTIONALLY_LEAK_OBJECT(env);
  70 #endif
  71   StartupCache::GetSingleton()->InvalidateCache();
  72 }
  73 TestStartupCache::~TestStartupCache() {
  74   PR_SetEnv("MOZ_STARTUP_CACHE=");
  75   StartupCache::GetSingleton()->InvalidateCache();
  76 }
  77
  78 TEST_F(TestStartupCache, StartupWriteRead) {
  79   nsresult rv;
  80   StartupCache* sc = StartupCache::GetSingleton();
  81
  82   const char* buf = "Market opportunities for BeardBook";
  83   const char* id = "id";
  84   const char* outbuf;
  85   uint32_t len;
  86
  87   rv = sc->PutBuffer(id, mozilla::UniqueFreePtr<char[]>(strdup(buf)),
  88                      strlen(buf) + 1);
  89   EXPECT_NS_SUCCEEDED(rv);
  90
  91   rv = sc->GetBuffer(id, &outbuf, &len);
  92   EXPECT_NS_SUCCEEDED(rv);
  93   EXPECT_STREQ(buf, outbuf);
  94
  95   rv = sc->ResetStartupWriteTimerAndLock();
  96   EXPECT_NS_SUCCEEDED(rv);
  97   WaitForStartupTimer();
  98
  99   rv = sc->GetBuffer(id, &outbuf, &len);
 100   EXPECT_NS_SUCCEEDED(rv);
 101   EXPECT_STREQ(buf, outbuf);
 102 }
 103
 104 TEST_F(TestStartupCache, WriteInvalidateRead) {
 105   nsresult rv;
 106   const char* buf = "BeardBook competitive analysis";
 107   const char* id = "id";
 108   const char* outbuf;
 109   uint32_t len;
 110   StartupCache* sc = StartupCache::GetSingleton();
 111   ASSERT_TRUE(sc);
 112
 113   rv = sc->PutBuffer(id, mozilla::UniqueFreePtr<char[]>(strdup(buf)),
 114                      strlen(buf) + 1);
 115   EXPECT_NS_SUCCEEDED(rv);
 116
 117   sc->InvalidateCache();
 118
 119   rv = sc->GetBuffer(id, &outbuf, &len);
 120   EXPECT_EQ(rv, NS_ERROR_NOT_AVAILABLE);
 121 }
 122
 123 TEST_F(TestStartupCache, WriteObject) {
 124   nsresult rv;
 125
 126   nsCOMPtr<nsIURI> obj;
 127
 128   constexpr auto spec = "http://www.mozilla.org"_ns;
 129   rv = NS_MutateURI(NS_SIMPLEURIMUTATOR_CONTRACTID).SetSpec(spec).Finalize(obj);
 130   EXPECT_NS_SUCCEEDED(rv);
 131
 132   StartupCache* sc = StartupCache::GetSingleton();
 133
 134   // Create an object stream. Usually this is done with
 135   // NewObjectOutputWrappedStorageStream, but that uses
 136   // StartupCache::GetSingleton in debug builds, and we
 137   // don't have access to that here. Obviously.
 138   const char* id = "id";
 139   nsCOMPtr<nsIStorageStream> storageStream =
 140       do_CreateInstance("@mozilla.org/storagestream;1");
 141   ASSERT_TRUE(storageStream);
 142
 143   rv = storageStream->Init(256, (uint32_t)-1);
 144   EXPECT_NS_SUCCEEDED(rv);
 145
 146   nsCOMPtr<nsIObjectOutputStream> objectOutput =
 147       do_CreateInstance("@mozilla.org/binaryoutputstream;1");
 148   ASSERT_TRUE(objectOutput);
 149
 150   nsCOMPtr<nsIOutputStream> outputStream = do_QueryInterface(storageStream);
 151
 152   rv = objectOutput->SetOutputStream(outputStream);
 153   EXPECT_NS_SUCCEEDED(rv);
 154
 155   nsCOMPtr<nsISupports> objQI(do_QueryInterface(obj));
 156   rv = objectOutput->WriteObject(objQI, true);
 157   EXPECT_NS_SUCCEEDED(rv);
 158
 159   mozilla::UniqueFreePtr<char[]> buf;
 160   uint32_t len;
 161   NewBufferFromStorageStream(storageStream, &buf, &len);
 162
 163   // Since this is a post-startup write, it should be written and
 164   // available.
 165   rv = sc->PutBuffer(id, std::move(buf), len);
 166   EXPECT_NS_SUCCEEDED(rv);
 167
 168   const char* buf2;
 169   uint32_t len2;
 170   nsCOMPtr<nsIObjectInputStream> objectInput;
 171   rv = sc->GetBuffer(id, &buf2, &len2);
 172   EXPECT_NS_SUCCEEDED(rv);
 173
 174   rv = NewObjectInputStreamFromBuffer(buf2, len2, getter_AddRefs(objectInput));
 175   EXPECT_NS_SUCCEEDED(rv);
 176
 177   nsCOMPtr<nsISupports> deserialized;
 178   rv = objectInput->ReadObject(true, getter_AddRefs(deserialized));
 179   EXPECT_NS_SUCCEEDED(rv);
 180
 181   nsCOMPtr<nsIURI> uri(do_QueryInterface(deserialized));
 182   ASSERT_TRUE(uri);
 183
 184   nsCString outSpec;
 185   rv = uri->GetSpec(outSpec);
 186   EXPECT_NS_SUCCEEDED(rv);
 187   ASSERT_TRUE(outSpec.Equals(spec));
 188 }