Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-07 09:54:42 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1314378 part B - port TestStartupCache to gtest, r=froydnj

Browse Source 
MozReview-Commit-ID: LTz4slzIkjH

--HG--
extra : rebase_source : 852ca996bd042d9c363b79bf47a037f83f3cf804
extra : source : 4585a7b6f3ce8c8dc7b7e043e0fae86f8e5ee392
This commit is contained in:
Benjamin Smedberg 2016-11-11 11:57:08 -05:00
parent d3f7e3065e
commit 067ef5e9f7
9 changed files with 123 additions and 385 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
python/mozbuild/mozbuild/frontend/emitter.py
View File

@ -140,7 +140,6 @@ ALLOWED_XPCOM_GLUE = {
('TestTXMgr', 'editor/txmgr/tests'),
('test_IHistory', 'toolkit/components/places/tests/cpp'),
('testcrasher', 'toolkit/crashreporter/test'),
('TestStartupCache', 'startupcache/test'),
('jsep_session_unittest', 'media/webrtc/signaling/test'),
('jsep_track_unittest', 'media/webrtc/signaling/test'),
('mediaconduit_unittests', 'media/webrtc/signaling/test'),

35
startupcache/StartupCache.cpp
View File

@ -153,7 +153,7 @@ StartupCache::Init()
// This allows to override the startup cache filename
// which is useful from xpcshell, when there is no ProfLDS directory to keep cache in.
char *env = PR_GetEnv("MOZ_STARTUP_CACHE");
if (env) {
if (env && *env) {
rv = NS_NewLocalFile(NS_ConvertUTF8toUTF16(env), false, getter_AddRefs(mFile));
} else {
nsCOMPtr<nsIFile> file;
@ -595,6 +595,13 @@ StartupCache::ResetStartupWriteTimer()
return NS_OK;
}
bool
StartupCache::StartupWriteComplete()
{
WaitOnWriteThread();
return mStartupWriteInitiated && mTable.Count() == 0;
}
// StartupCacheDebugOutputStream implementation
#ifdef DEBUG
NS_IMPL_ISUPPORTS(StartupCacheDebugOutputStream, nsIObjectOutputStream,
@ -737,13 +744,6 @@ StartupCacheWrapper::InvalidateCache()
return NS_OK;
}
nsresult
StartupCacheWrapper::IgnoreDiskCache()
{
StartupCache::IgnoreDiskCache();
return NS_OK;
}
nsresult
StartupCacheWrapper::GetDebugObjectOutputStream(nsIObjectOutputStream* stream,
nsIObjectOutputStream** outStream)
@ -755,25 +755,6 @@ StartupCacheWrapper::GetDebugObjectOutputStream(nsIObjectOutputStream* stream,
return sc->GetDebugObjectOutputStream(stream, outStream);
}
nsresult
StartupCacheWrapper::StartupWriteComplete(bool *complete)
{
StartupCache* sc = StartupCache::GetSingleton();
if (!sc) {
return NS_ERROR_NOT_INITIALIZED;
}
sc->WaitOnWriteThread();
*complete = sc->mStartupWriteInitiated && sc->mTable.Count() == 0;
return NS_OK;
}
nsresult
StartupCacheWrapper::ResetStartupWriteTimer()
{
StartupCache* sc = StartupCache::GetSingleton();
return sc ? sc->ResetStartupWriteTimer() : NS_ERROR_NOT_INITIALIZED;
}
nsresult
StartupCacheWrapper::GetObserver(nsIObserver** obv) {
StartupCache* sc = StartupCache::GetSingleton();

4
startupcache/StartupCache.h
View File

@ -138,6 +138,9 @@ public:
size_t SizeOfMapping();
// FOR TESTING ONLY
nsresult ResetStartupWriteTimer();
bool StartupWriteComplete();
private:
StartupCache();
virtual ~StartupCache();
@ -145,7 +148,6 @@ private:
nsresult LoadArchive();
nsresult Init();
void WriteToDisk();
nsresult ResetStartupWriteTimer();
void WaitOnWriteThread();
static nsresult InitSingleton();

14
startupcache/StartupCacheUtils.cpp
View File

@ -18,8 +18,8 @@
namespace mozilla {
namespace scache {
NS_EXPORT nsresult
NewObjectInputStreamFromBuffer(UniquePtr<char[]> buffer, uint32_t len,
nsresult
NewObjectInputStreamFromBuffer(UniquePtr<char[]> buffer, uint32_t len,
nsIObjectInputStream** stream)
{
nsCOMPtr<nsIStringInputStream> stringStream =
@ -37,7 +37,7 @@ NewObjectInputStreamFromBuffer(UniquePtr<char[]> buffer, uint32_t len,
return NS_OK;
}
NS_EXPORT nsresult
nsresult
NewObjectOutputWrappedStorageStream(nsIObjectOutputStream **wrapperStream,
nsIStorageStream** stream,
bool wantDebugStream)
@ -74,9 +74,9 @@ NewObjectOutputWrappedStorageStream(nsIObjectOutputStream **wrapperStream,
return NS_OK;
}
NS_EXPORT nsresult
NewBufferFromStorageStream(nsIStorageStream *storageStream,
UniquePtr<char[]>* buffer, uint32_t* len)
nsresult
NewBufferFromStorageStream(nsIStorageStream *storageStream,
UniquePtr<char[]>* buffer, uint32_t* len)
{
nsresult rv;
nsCOMPtr<nsIInputStream> inputStream;
@ -170,7 +170,7 @@ canonicalizeBase(nsAutoCString &spec,
* jar:file://$PROFILE_DIR/extensions/some.xpi!/components/component.js becomes
* jsloader/$PROFILE_DIR/extensions/some.xpi/components/component.js
*/
NS_EXPORT nsresult
nsresult
PathifyURI(nsIURI *in, nsACString &out)
{
bool equals;

11
startupcache/StartupCacheUtils.h
View File

@ -5,15 +5,18 @@
#ifndef nsStartupCacheUtils_h_
#define nsStartupCacheUtils_h_
#include "nsString.h"
#include "nsIStorageStream.h"
#include "nsIObjectInputStream.h"
#include "nsIObjectOutputStream.h"
#include "mozilla/UniquePtr.h"
class nsIURI;
namespace mozilla {
namespace scache {
NS_EXPORT nsresult
nsresult
NewObjectInputStreamFromBuffer(UniquePtr<char[]> buffer, uint32_t len,
nsIObjectInputStream** stream);
@ -23,7 +26,7 @@ NewObjectInputStreamFromBuffer(UniquePtr<char[]> buffer, uint32_t len,
// non-singleton objects are written out multiple times during a serialization.
// This could cause them to be deserialized incorrectly (as multiple copies
// instead of references).
NS_EXPORT nsresult
nsresult
NewObjectOutputWrappedStorageStream(nsIObjectOutputStream **wrapperStream,
nsIStorageStream** stream,
bool wantDebugStream);
@ -31,11 +34,11 @@ NewObjectOutputWrappedStorageStream(nsIObjectOutputStream **wrapperStream,
// Creates a buffer for storing the stream into the cache. The buffer is
// allocated with 'new []'. After calling this function, the caller would
// typically call nsIStartupCache::PutBuffer with the returned buffer.
NS_EXPORT nsresult
nsresult
NewBufferFromStorageStream(nsIStorageStream *storageStream,
UniquePtr<char[]>* buffer, uint32_t* len);
NS_EXPORT nsresult
nsresult
PathifyURI(nsIURI *in, nsACString &out);
} // namespace scache
} // namespace mozilla

8
startupcache/nsIStartupCache.idl
View File

@ -40,7 +40,6 @@ interface nsIStartupCache : nsISupports
void invalidateCache();
void ignoreDiskCache();
/** In debug builds, wraps this object output stream with a stream that will
* detect and prevent the write of a multiply-referenced non-singleton object
@ -48,13 +47,6 @@ interface nsIStartupCache : nsISupports
* original stream, unwrapped. */
nsIObjectOutputStream getDebugObjectOutputStream(in nsIObjectOutputStream aStream);
/* Allows clients to check whether the one-time writeout after startup
* has finished yet, and also to set this variable as needed (so test
* code can fire mulitple startup writes if needed).
*/
boolean startupWriteComplete();
void resetStartupWriteTimer();
/* Allows clients to simulate the behavior of ObserverService. */
readonly attribute nsIObserver observer;
};

425
startupcache/test/TestStartupCache.cpp
View File

@ -3,164 +3,139 @@
* 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 "TestHarness.h"
#include "gtest/gtest.h"
#include "nsThreadUtils.h"
#include "mozilla/scache/StartupCache.h"
#include "mozilla/scache/StartupCacheUtils.h"
#include "nsDirectoryServiceDefs.h"
#include "nsIClassInfo.h"
#include "nsIOutputStream.h"
#include "nsIObserver.h"
#include "nsISerializable.h"
#include "nsISupports.h"
#include "nsIStartupCache.h"
#include "nsIStringStream.h"
#include "nsIStorageStream.h"
#include "nsIObjectInputStream.h"
#include "nsIObjectOutputStream.h"
#include "nsIURI.h"
#include "nsStringAPI.h"
#include "nsIPrefBranch.h"
#include "nsIPrefService.h"
#include "nsIXPConnect.h"
#include "nsThreadUtils.h"
#include "prenv.h"
#include "prio.h"
#include "prprf.h"
#include "mozilla/Maybe.h"
#include "mozilla/UniquePtr.h"
using namespace JS;
namespace mozilla {
namespace scache {
NS_IMPORT nsresult
NewObjectInputStreamFromBuffer(UniquePtr<char[]> buffer, uint32_t len,
nsIObjectInputStream** stream);
// We can't retrieve the wrapped stream from the objectOutputStream later,
// so we return it here.
NS_IMPORT nsresult
NewObjectOutputWrappedStorageStream(nsIObjectOutputStream **wrapperStream,
nsIStorageStream** stream);
NS_IMPORT nsresult
NewBufferFromStorageStream(nsIStorageStream *storageStream,
UniquePtr<char[]>* buffer, uint32_t* len);
} // namespace scache
} // namespace mozilla
using namespace mozilla::scache;
using mozilla::UniquePtr;
#define NS_ENSURE_STR_MATCH(str1, str2, testname) \
PR_BEGIN_MACRO \
if (0 != strcmp(str1, str2)) { \
fail("failed " testname); \
return NS_ERROR_FAILURE; \
} \
passed("passed " testname); \
PR_END_MACRO
nsresult
WaitForStartupTimer() {
nsresult rv;
nsCOMPtr<nsIStartupCache> sc
= do_GetService("@mozilla.org/startupcache/cache;1");
void
WaitForStartupTimer()
{
StartupCache* sc = StartupCache::GetSingleton();
PR_Sleep(10 * PR_TicksPerSecond());
bool complete;
while (true) {
NS_ProcessPendingEvents(nullptr);
rv = sc->StartupWriteComplete(&complete);
if (NS_FAILED(rv) || complete)
break;
if (sc->StartupWriteComplete()) {
return;
}
PR_Sleep(1 * PR_TicksPerSecond());
}
return rv;
}
nsresult
TestStartupWriteRead() {
class TestStartupCache : public ::testing::Test
{
protected:
TestStartupCache();
~TestStartupCache();
nsCOMPtr<nsIFile> mSCFile;
};
TestStartupCache::TestStartupCache()
{
NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(mSCFile));
mSCFile->AppendNative(NS_LITERAL_CSTRING("test-startupcache.tmp"));
nsAutoCString path;
mSCFile->GetNativePath(path);
char* env = PR_smprintf("MOZ_STARTUP_CACHE=%s", path.get());
PR_SetEnv(env);
// We intentionally leak `env` here because it is required by PR_SetEnv
MOZ_LSAN_INTENTIONALLY_LEAK_OBJECT(env);
StartupCache::GetSingleton()->InvalidateCache();
}
TestStartupCache::~TestStartupCache()
{
PR_SetEnv("MOZ_STARTUP_CACHE=");
StartupCache::GetSingleton()->InvalidateCache();
}
TEST_F(TestStartupCache, StartupWriteRead)
{
nsresult rv;
nsCOMPtr<nsIStartupCache> sc
= do_GetService("@mozilla.org/startupcache/cache;1", &rv);
if (!sc) {
fail("didn't get a pointer...");
return NS_ERROR_FAILURE;
} else {
passed("got a pointer?");
}
sc->InvalidateCache();
StartupCache* sc = StartupCache::GetSingleton();
const char* buf = "Market opportunities for BeardBook";
const char* id = "id";
UniquePtr<char[]> outbuf;
UniquePtr<char[]> outbuf;
uint32_t len;
rv = sc->PutBuffer(id, buf, strlen(buf) + 1);
NS_ENSURE_SUCCESS(rv, rv);
EXPECT_TRUE(NS_SUCCEEDED(rv));
rv = sc->GetBuffer(id, &outbuf, &len);
NS_ENSURE_SUCCESS(rv, rv);
NS_ENSURE_STR_MATCH(buf, outbuf.get(), "pre-write read");
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_STREQ(buf, outbuf.get());
rv = sc->ResetStartupWriteTimer();
rv = WaitForStartupTimer();
NS_ENSURE_SUCCESS(rv, rv);
rv = sc->GetBuffer(id, &outbuf, &len);
NS_ENSURE_SUCCESS(rv, rv);
NS_ENSURE_STR_MATCH(buf, outbuf.get(), "simple write/read");
EXPECT_TRUE(NS_SUCCEEDED(rv));
WaitForStartupTimer();
return NS_OK;
rv = sc->GetBuffer(id, &outbuf, &len);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_STREQ(buf, outbuf.get());
}
nsresult
TestWriteInvalidateRead() {
TEST_F(TestStartupCache, WriteInvalidateRead)
{
nsresult rv;
const char* buf = "BeardBook competitive analysis";
const char* id = "id";
UniquePtr<char[]> outbuf;
uint32_t len;
nsCOMPtr<nsIStartupCache> sc
= do_GetService("@mozilla.org/startupcache/cache;1", &rv);
sc->InvalidateCache();
StartupCache* sc = StartupCache::GetSingleton();
ASSERT_TRUE(sc);
rv = sc->PutBuffer(id, buf, strlen(buf) + 1);
NS_ENSURE_SUCCESS(rv, rv);
EXPECT_TRUE(NS_SUCCEEDED(rv));
sc->InvalidateCache();
rv = sc->GetBuffer(id, &outbuf, &len);
if (rv == NS_ERROR_NOT_AVAILABLE) {
passed("buffer not available after invalidate");
} else if (NS_SUCCEEDED(rv)) {
fail("GetBuffer succeeded unexpectedly after invalidate");
return NS_ERROR_UNEXPECTED;
} else {
fail("GetBuffer gave an unexpected failure, expected NOT_AVAILABLE");
return rv;
}
sc->InvalidateCache();
return NS_OK;
EXPECT_EQ(rv, NS_ERROR_NOT_AVAILABLE);
}
nsresult
TestWriteObject() {
TEST_F(TestStartupCache, WriteObject)
{
nsresult rv;
nsCOMPtr<nsIURI> obj
= do_CreateInstance("@mozilla.org/network/simple-uri;1");
if (!obj) {
fail("did not create object in test write object");
return NS_ERROR_UNEXPECTED;
}
ASSERT_TRUE(obj);
NS_NAMED_LITERAL_CSTRING(spec, "http://www.mozilla.org");
rv = obj->SetSpec(spec);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIStartupCache> sc = do_GetService("@mozilla.org/startupcache/cache;1", &rv);
EXPECT_TRUE(NS_SUCCEEDED(rv));
StartupCache* sc = StartupCache::GetSingleton();
sc->InvalidateCache();
// Create an object stream. Usually this is done with
// NewObjectOutputWrappedStorageStream, but that uses
// StartupCache::GetSingleton in debug builds, and we
@ -168,31 +143,24 @@ TestWriteObject() {
const char* id = "id";
nsCOMPtr<nsIStorageStream> storageStream
= do_CreateInstance("@mozilla.org/storagestream;1");
NS_ENSURE_ARG_POINTER(storageStream);
ASSERT_TRUE(storageStream);
rv = storageStream->Init(256, (uint32_t) -1);
NS_ENSURE_SUCCESS(rv, rv);
EXPECT_TRUE(NS_SUCCEEDED(rv));
nsCOMPtr<nsIObjectOutputStream> objectOutput
= do_CreateInstance("@mozilla.org/binaryoutputstream;1");
if (!objectOutput)
return NS_ERROR_OUT_OF_MEMORY;
ASSERT_TRUE(objectOutput);
nsCOMPtr<nsIOutputStream> outputStream
= do_QueryInterface(storageStream);
rv = objectOutput->SetOutputStream(outputStream);
if (NS_FAILED(rv)) {
fail("failed to create output stream");
return rv;
}
rv = objectOutput->SetOutputStream(outputStream);
EXPECT_TRUE(NS_SUCCEEDED(rv));
nsCOMPtr<nsISupports> objQI(do_QueryInterface(obj));
rv = objectOutput->WriteObject(objQI, true);
if (NS_FAILED(rv)) {
fail("failed to write object");
return rv;
}
EXPECT_TRUE(NS_SUCCEEDED(rv));
UniquePtr<char[]> buf;
uint32_t len;
@ -201,232 +169,27 @@ TestWriteObject() {
// Since this is a post-startup write, it should be written and
// available.
rv = sc->PutBuffer(id, buf.get(), len);
if (NS_FAILED(rv)) {
fail("failed to insert input stream");
return rv;
}
EXPECT_TRUE(NS_SUCCEEDED(rv));
UniquePtr<char[]> buf2;
uint32_t len2;
nsCOMPtr<nsIObjectInputStream> objectInput;
rv = sc->GetBuffer(id, &buf2, &len2);
if (NS_FAILED(rv)) {
fail("failed to retrieve buffer");
return rv;
}
EXPECT_TRUE(NS_SUCCEEDED(rv));
rv = NewObjectInputStreamFromBuffer(Move(buf2), len2,
getter_AddRefs(objectInput));
if (NS_FAILED(rv)) {
fail("failed to created input stream");
return rv;
}
EXPECT_TRUE(NS_SUCCEEDED(rv));
nsCOMPtr<nsISupports> deserialized;
rv = objectInput->ReadObject(true, getter_AddRefs(deserialized));
if (NS_FAILED(rv)) {
fail("failed to read object");
return rv;
}
bool match = false;
EXPECT_TRUE(NS_SUCCEEDED(rv));
nsCOMPtr<nsIURI> uri(do_QueryInterface(deserialized));
if (uri) {
nsCString outSpec;
rv = uri->GetSpec(outSpec);
if (NS_FAILED(rv)) {
fail("failed to get spec");
return rv;
}
match = outSpec.Equals(spec);
}
if (!match) {
fail("deserialized object has incorrect information");
return rv;
}
passed("write object");
return NS_OK;
}
nsresult
LockCacheFile(bool protect, nsIFile* profileDir) {
NS_ENSURE_ARG(profileDir);
nsCOMPtr<nsIFile> startupCache;
profileDir->Clone(getter_AddRefs(startupCache));
NS_ENSURE_STATE(startupCache);
startupCache->AppendNative(NS_LITERAL_CSTRING("startupCache"));
nsresult rv;
#ifndef XP_WIN
static uint32_t oldPermissions;
#else
static PRFileDesc* fd = nullptr;
#endif
// To prevent deletion of the startupcache file, we change the containing
// directory's permissions on Linux/Mac, and hold the file open on Windows
if (protect) {
#ifndef XP_WIN
rv = startupCache->GetPermissions(&oldPermissions);
NS_ENSURE_SUCCESS(rv, rv);
rv = startupCache->SetPermissions(0555);
NS_ENSURE_SUCCESS(rv, rv);
#else
// Filename logic from StartupCache.cpp
#ifdef IS_BIG_ENDIAN
#define SC_ENDIAN "big"
#else
#define SC_ENDIAN "little"
#endif
#if PR_BYTES_PER_WORD == 4
#define SC_WORDSIZE "4"
#else
#define SC_WORDSIZE "8"
#endif
char sStartupCacheName[] = "startupCache." SC_WORDSIZE "." SC_ENDIAN;
startupCache->AppendNative(NS_LITERAL_CSTRING(sStartupCacheName));
rv = startupCache->OpenNSPRFileDesc(PR_RDONLY, 0, &fd);
NS_ENSURE_SUCCESS(rv, rv);
#endif
} else {
#ifndef XP_WIN
rv = startupCache->SetPermissions(oldPermissions);
NS_ENSURE_SUCCESS(rv, rv);
#else
PR_Close(fd);
#endif
}
return NS_OK;
}
nsresult
TestIgnoreDiskCache(nsIFile* profileDir) {
nsresult rv;
nsCOMPtr<nsIStartupCache> sc
= do_GetService("@mozilla.org/startupcache/cache;1", &rv);
sc->InvalidateCache();
const char* buf = "Get a Beardbook app for your smartphone";
const char* id = "id";
UniquePtr<char[]> outbuf;
uint32_t len;
rv = sc->PutBuffer(id, buf, strlen(buf) + 1);
NS_ENSURE_SUCCESS(rv, rv);
rv = sc->ResetStartupWriteTimer();
rv = WaitForStartupTimer();
NS_ENSURE_SUCCESS(rv, rv);
// Prevent StartupCache::InvalidateCache from deleting the disk file
rv = LockCacheFile(true, profileDir);
NS_ENSURE_SUCCESS(rv, rv);
sc->IgnoreDiskCache();
rv = sc->GetBuffer(id, &outbuf, &len);
nsresult r = LockCacheFile(false, profileDir);
NS_ENSURE_SUCCESS(r, r);
if (rv == NS_ERROR_NOT_AVAILABLE) {
passed("buffer not available after ignoring disk cache");
} else if (NS_SUCCEEDED(rv)) {
fail("GetBuffer succeeded unexpectedly after ignoring disk cache");
return NS_ERROR_UNEXPECTED;
} else {
fail("GetBuffer gave an unexpected failure, expected NOT_AVAILABLE");
return rv;
}
sc->InvalidateCache();
return NS_OK;
}
nsresult
TestEarlyShutdown() {
nsresult rv;
nsCOMPtr<nsIStartupCache> sc
= do_GetService("@mozilla.org/startupcache/cache;1", &rv);
sc->InvalidateCache();
const char* buf = "Find your soul beardmate on BeardBook";
const char* id = "id";
uint32_t len;
UniquePtr<char[]> outbuf;
sc->ResetStartupWriteTimer();
rv = sc->PutBuffer(id, buf, strlen(buf) + 1);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIObserver> obs;
sc->GetObserver(getter_AddRefs(obs));
obs->Observe(nullptr, "xpcom-shutdown", nullptr);
rv = WaitForStartupTimer();
NS_ENSURE_SUCCESS(rv, rv);
rv = sc->GetBuffer(id, &outbuf, &len);
if (NS_SUCCEEDED(rv)) {
passed("GetBuffer succeeded after early shutdown");
} else {
fail("GetBuffer failed after early shutdown");
return rv;
}
const char* other_id = "other_id";
rv = sc->PutBuffer(other_id, buf, strlen(buf) + 1);
if (rv == NS_ERROR_NOT_AVAILABLE) {
passed("PutBuffer not available after early shutdown");
} else if (NS_SUCCEEDED(rv)) {
fail("PutBuffer succeeded unexpectedly after early shutdown");
return NS_ERROR_UNEXPECTED;
} else {
fail("PutBuffer gave an unexpected failure, expected NOT_AVAILABLE");
return rv;
}
return NS_OK;
}
int main(int argc, char** argv)
{
ScopedXPCOM xpcom("Startup Cache");
if (xpcom.failed())
return 1;
nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID);
if (!prefs) {
fail("prefs");
return 1;
}
prefs->SetIntPref("hangmonitor.timeout", 0);
int rv = 0;
nsresult scrv;
nsCOMPtr<nsIStartupCache> sc
= do_GetService("@mozilla.org/startupcache/cache;1", &scrv);
if (NS_FAILED(scrv))
rv = 1;
else
sc->RecordAgesAlways();
if (NS_FAILED(TestStartupWriteRead()))
rv = 1;
if (NS_FAILED(TestWriteInvalidateRead()))
rv = 1;
if (NS_FAILED(TestWriteObject()))
rv = 1;
nsCOMPtr<nsIFile> profileDir = xpcom.GetProfileDirectory();
if (NS_FAILED(TestIgnoreDiskCache(profileDir)))
rv = 1;
if (NS_FAILED(TestEarlyShutdown()))
rv = 1;
return rv;
ASSERT_TRUE(uri);
nsCString outSpec;
rv = uri->GetSpec(outSpec);
EXPECT_TRUE(NS_SUCCEEDED(rv));
ASSERT_TRUE(outSpec.Equals(spec));
}

7
startupcache/test/moz.build
View File

@ -4,6 +4,7 @@
# 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/.
GeckoCppUnitTests([
'TestStartupCache',
])
UNIFIED_SOURCES += [
'TestStartupCache.cpp',
]
FINAL_LIBRARY = 'xul-gtest'

3
testing/cppunittest.ini
View File

@ -41,9 +41,6 @@ skip-if = os == 'android' # Bug 1147630
[TestSHA1]
[TestSaturate]
[TestSplayTree]
[TestStartupCache]
skip-if = os == 'b2g' || os == 'android' # Bug 929655
support-files = TestStartupCacheTelemetry.js TestStartupCacheTelemetry.manifest
[TestSyncRunnable]
[TestTXMgr]
skip-if = os == 'b2g' #Bug 919595