nagai/fune
3
0
Fork 0
forked from mirrors/gecko-dev
Code Pull requests Activity

Bug 1790614 - Part 2: Use {ASSERT,ENSURE}_NS_{SUCCEEEDED,FAILED} in gtests, r=ahal,necko-reviewers

Browse source 
These macros will produce better outputs when they fail than these existing
patterns using `ENSURE_TRUE(NS_SUCCEEDED(...))` or similar, so this is a bulk
rewrite of existing tests to use them.

It should also help with discoverability when people base their tests off of
other existing tests.

Differential Revision: https://phabricator.services.mozilla.com/D157214
This commit is contained in:
Nika Layzell 2022-09-15 14:51:50 +00:00
parent 8aa98212cc
commit 0316dc51b9
73 changed files with 949 additions and 890 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

7
caps/tests/gtest/TestNullPrincipalPrecursor.cpp
View file

@ -2,6 +2,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/. */
#include "gtest/gtest.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/NullPrincipal.h"
#include "nsIURIMutator.h"
#include "nsPrintfCString.h"
@ -38,10 +39,10 @@ TEST(NullPrincipalPrecursor, EscapingRoundTrips)
// Make sure that this escaped URI round-trips through a `moz-nullprincipal`
// URI's query without any additional escapes.
nsCOMPtr<nsIURI> clone;
EXPECT_TRUE(
NS_SUCCEEDED(NS_MutateURI(baseURI).SetQuery(escaped).Finalize(clone)));
EXPECT_NS_SUCCEEDED(
NS_MutateURI(baseURI).SetQuery(escaped).Finalize(clone));
nsCString query;
EXPECT_TRUE(NS_SUCCEEDED(clone->GetQuery(query)));
EXPECT_NS_SUCCEEDED(clone->GetQuery(query));
EXPECT_EQ(escaped, query);
// Try to unescape our escaped URI and make sure we recover the input

9
dom/fs/test/gtest/parent/datamodel/TestFileSystemDataManager.cpp
View file

@ -12,6 +12,7 @@
#include "mozilla/dom/ScriptSettings.h"
#include "mozilla/dom/quota/QuotaManager.h"
#include "mozilla/dom/quota/QuotaManagerService.h"
#include "mozilla/gtest/MozAssertions.h"
#include "nsIPrefBranch.h"
#include "nsIPrefService.h"
#include "nsIQuotaCallbacks.h"
@ -61,7 +62,7 @@ class TestFileSystemDataManager : public ::testing::Test {
ASSERT_TRUE(observer);
nsresult rv = observer->Observe(nullptr, "profile-do-change", nullptr);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
AutoJSAPI jsapi;
@ -79,14 +80,14 @@ class TestFileSystemDataManager : public ::testing::Test {
nsCOMPtr<nsIQuotaRequest> request;
rv = qms->StorageInitialized(getter_AddRefs(request));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
prefs->SetBoolPref("dom.quotaManager.testing", false);
RefPtr<RequestResolver> resolver = new RequestResolver();
rv = request->SetCallback(resolver);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
SpinEventLoopUntil("Promise is fulfilled"_ns,
[&resolver]() { return resolver->Done(); });
@ -105,7 +106,7 @@ class TestFileSystemDataManager : public ::testing::Test {
nsresult rv =
observer->Observe(nullptr, "profile-before-change-qm", nullptr);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
bool done = false;

5
dom/media/doctor/test/gtest/TestMultiWriterQueue.cpp
View file

@ -7,6 +7,7 @@
#include "MultiWriterQueue.h"
#include "DDTimeStamp.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/Assertions.h"
#include "nsDeque.h"
#include "nsIThread.h"
@ -110,7 +111,7 @@ static void TestMultiWriterQueueMT(int aWriterThreads, int aReaderThreads,
if (k < aReaderThreads) {
nsCOMPtr<nsIThread> t;
nsresult rv = NS_NewNamedThread("MWQThread", getter_AddRefs(t));
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
NS_ADDREF(array[k] = t);
} else {
nsCOMPtr<nsIThread> t;
@ -129,7 +130,7 @@ static void TestMultiWriterQueueMT(int aWriterThreads, int aReaderThreads,
++pushThreadsCompleted;
});
nsresult rv = NS_NewNamedThread("MWQThread", getter_AddRefs(t), r);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
NS_ADDREF(array[k] = t);
}
}

57
dom/media/gtest/TestCDMStorage.cpp
View file

@ -10,6 +10,7 @@
#include "GMPTestMonitor.h"
#include "MediaResult.h"
#include "gtest/gtest.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/RefPtr.h"
#include "mozilla/SchedulerGroup.h"
#include "mozilla/SpinEventLoopUntil.h"
@ -27,7 +28,7 @@ static already_AddRefed<nsIThread> GetGMPThread() {
RefPtr<GeckoMediaPluginService> service =
GeckoMediaPluginService::GetGeckoMediaPluginService();
nsCOMPtr<nsIThread> thread;
EXPECT_TRUE(NS_SUCCEEDED(service->GetThread(getter_AddRefs(thread))));
EXPECT_NS_SUCCEEDED(service->GetThread(getter_AddRefs(thread)));
return thread.forget();
}
@ -273,7 +274,7 @@ static bool IsCDMStorageIsEmpty() {
MOZ_ASSERT(service);
nsCOMPtr<nsIFile> storage;
nsresult rv = service->GetStorageDir(getter_AddRefs(storage));
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
bool exists = false;
if (storage) {
storage->Exists(&exists);
@ -484,7 +485,7 @@ class CDMStorageTest {
void operator()(nsIFile* aFile) {
nsCString salt;
nsresult rv = ReadSalt(aFile, salt);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
if (!MatchOrigin(aFile, mNodeInfo->siteToForget, mNodeInfo->mPattern)) {
mNodeInfo->mExpectedRemainingNodeIds.AppendElement(salt);
}
@ -536,7 +537,7 @@ class CDMStorageTest {
void operator()(nsIFile* aFile) {
nsCString salt;
nsresult rv = ReadSalt(aFile, salt);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Shouldn't match the origin if we clear correctly.
EXPECT_FALSE(
MatchOrigin(aFile, mNodeInfo->siteToForget, mNodeInfo->mPattern))
@ -565,7 +566,7 @@ class CDMStorageTest {
void operator()(nsIFile* aFile) {
nsCString salt;
nsresult rv = aFile->GetNativeLeafName(salt);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
EXPECT_TRUE(mExpectedRemainingNodeIds.RemoveElement(salt))
<< "Failed to remove salt from expected remaining node ids. This "
"indicates storage that should be forgotten is still persisted!";
@ -583,10 +584,10 @@ class CDMStorageTest {
void TestForgetThisSite_Verify(UniquePtr<NodeInfo>&& aSiteInfo) {
nsresult rv =
EnumerateCDMStorageDir("id"_ns, NodeIdVerifier(aSiteInfo.get()));
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
rv = EnumerateCDMStorageDir("storage"_ns, StorageVerifier(aSiteInfo.get()));
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
}
/**
@ -651,7 +652,7 @@ class CDMStorageTest {
void operator()(nsIFile* aFile) {
nsCString salt;
nsresult rv = ReadSalt(aFile, salt);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
if (!MatchBaseDomain(aFile, mNodeInfo->baseDomainToForget)) {
mNodeInfo->mExpectedRemainingNodeIds.AppendElement(salt);
}
@ -705,7 +706,7 @@ class CDMStorageTest {
void operator()(nsIFile* aFile) {
nsCString salt;
nsresult rv = ReadSalt(aFile, salt);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Shouldn't match the origin if we clear correctly.
EXPECT_FALSE(MatchBaseDomain(aFile, mNodeInfo->baseDomainToForget))
<< "Found files persisted that match against a domain that should "
@ -733,7 +734,7 @@ class CDMStorageTest {
void operator()(nsIFile* aFile) {
nsCString salt;
nsresult rv = aFile->GetNativeLeafName(salt);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
EXPECT_TRUE(mExpectedRemainingNodeIds.RemoveElement(salt))
<< "Failed to remove salt from expected remaining node ids. This "
"indicates storage that should be forgotten is still persisted!";
@ -754,11 +755,11 @@ class CDMStorageTest {
UniquePtr<BaseDomainNodeInfo>&& aSiteInfo) {
nsresult rv = EnumerateCDMStorageDir(
"id"_ns, BaseDomainNodeIdVerifier(aSiteInfo.get()));
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
rv = EnumerateCDMStorageDir("storage"_ns,
BaseDomainStorageVerifier(aSiteInfo.get()));
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
}
/**
@ -844,7 +845,7 @@ class CDMStorageTest {
void TestClearRecentHistory1_Clear() {
MaxMTimeFinder f;
nsresult rv = EnumerateCDMStorageDir("id"_ns, f);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIRunnable> r = NewRunnableMethod(
"CDMStorageTest::TestClearRecentHistory_CheckEmpty", this,
@ -856,7 +857,7 @@ class CDMStorageTest {
void TestClearRecentHistory2_Clear() {
MaxMTimeFinder f;
nsresult rv = EnumerateCDMStorageDir("storage"_ns, f);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIRunnable> r = NewRunnableMethod(
"CDMStorageTest::TestClearRecentHistory_CheckEmpty", this,
@ -868,7 +869,7 @@ class CDMStorageTest {
void TestClearRecentHistory3_Clear() {
MaxMTimeFinder f;
nsresult rv = EnumerateCDMStorageDir("storage"_ns, f);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIRunnable> r = NewRunnableMethod(
"CDMStorageTest::TestClearRecentHistory_CheckNonEmpty", this,
@ -890,13 +891,13 @@ class CDMStorageTest {
void TestClearRecentHistory_CheckEmpty() {
FileCounter c1;
nsresult rv = EnumerateCDMStorageDir("id"_ns, c1);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
// There should be no files under $profileDir/gmp/$platform/gmp-fake/id/
EXPECT_EQ(c1.GetCount(), 0);
FileCounter c2;
rv = EnumerateCDMStorageDir("storage"_ns, c2);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
// There should be no files under
// $profileDir/gmp/$platform/gmp-fake/storage/
EXPECT_EQ(c2.GetCount(), 0);
@ -907,14 +908,14 @@ class CDMStorageTest {
void TestClearRecentHistory_CheckNonEmpty() {
FileCounter c1;
nsresult rv = EnumerateCDMStorageDir("id"_ns, c1);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
// There should be one directory under
// $profileDir/gmp/$platform/gmp-fake/id/
EXPECT_EQ(c1.GetCount(), 1);
FileCounter c2;
rv = EnumerateCDMStorageDir("storage"_ns, c2);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
// There should be one directory under
// $profileDir/gmp/$platform/gmp-fake/storage/
EXPECT_EQ(c2.GetCount(), 1);
@ -1219,14 +1220,14 @@ static nsresult CreateTestDirectory(nsCOMPtr<nsIFile>& aOut) {
void TestMatchBaseDomain_MatchOrigin() {
nsCOMPtr<nsIFile> testDir;
nsresult rv = CreateTestDirectory(testDir);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
rv = WriteToFile(testDir, "origin"_ns,
"https://video.subdomain.removeme.github.io"_ns);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
rv = WriteToFile(testDir, "topLevelOrigin"_ns,
"https://embedder.example.com"_ns);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
bool result = MatchBaseDomain(testDir, "removeme.github.io"_ns);
EXPECT_TRUE(result);
testDir->Remove(true);
@ -1235,14 +1236,14 @@ void TestMatchBaseDomain_MatchOrigin() {
void TestMatchBaseDomain_MatchTLD() {
nsCOMPtr<nsIFile> testDir;
nsresult rv = CreateTestDirectory(testDir);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
rv = WriteToFile(testDir, "origin"_ns,
"https://video.example.com^userContextId=4"_ns);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
rv = WriteToFile(testDir, "topLevelOrigin"_ns,
"https://evil.web.megacorp.co.uk^privateBrowsingId=1"_ns);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
bool result = MatchBaseDomain(testDir, "megacorp.co.uk"_ns);
EXPECT_TRUE(result);
testDir->Remove(true);
@ -1251,14 +1252,14 @@ void TestMatchBaseDomain_MatchTLD() {
void TestMatchBaseDomain_NoMatch() {
nsCOMPtr<nsIFile> testDir;
nsresult rv = CreateTestDirectory(testDir);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
rv = WriteToFile(testDir, "origin"_ns,
"https://video.example.com^userContextId=4"_ns);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
rv = WriteToFile(testDir, "topLevelOrigin"_ns,
"https://evil.web.megacorp.co.uk^privateBrowsingId=1"_ns);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
bool result = MatchBaseDomain(testDir, "longer-example.com"_ns);
EXPECT_FALSE(result);
testDir->Remove(true);

7
dom/media/gtest/TestGMPCrossOrigin.cpp
View file

@ -5,6 +5,7 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "gtest/gtest.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/StaticPtr.h"
#include "GMPTestMonitor.h"
#include "GMPVideoDecoderProxy.h"
@ -103,7 +104,7 @@ class RunTestGMPCrossOrigin : public Base {
UniquePtr<typename Base::GMPCallbackType> callback(
new Step2(Base::mMonitor, aGMP, mShouldBeEqual));
nsresult rv = Base::Get(mOrigin2, std::move(callback));
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
if (NS_FAILED(rv)) {
Base::mMonitor.SetFinished();
}
@ -114,7 +115,7 @@ class RunTestGMPCrossOrigin : public Base {
UniquePtr<typename Base::GMPCallbackType> callback(
new RunTestGMPCrossOrigin<Base>(aMonitor, aOrigin1, aOrigin2));
nsresult rv = Base::Get(aOrigin1, std::move(callback));
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
if (NS_FAILED(rv)) {
aMonitor.SetFinished();
}
@ -181,7 +182,7 @@ void GMPTestRunner::DoTest(
RefPtr<GeckoMediaPluginService> service =
GeckoMediaPluginService::GetGeckoMediaPluginService();
nsCOMPtr<nsIThread> thread;
EXPECT_TRUE(NS_SUCCEEDED(service->GetThread(getter_AddRefs(thread))));
EXPECT_NS_SUCCEEDED(service->GetThread(getter_AddRefs(thread)));
GMPTestMonitor monitor;
thread->Dispatch(NewRunnableMethod<GMPTestMonitor&>(

7
dom/media/gtest/TestMediaDataDecoder.cpp
View file

@ -12,6 +12,7 @@
#include "WebMDecoder.h"
#include "WebMDemuxer.h"
#include "mozilla/AbstractThread.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/SpinEventLoopUntil.h"
#include "nsMimeTypes.h"
@ -54,7 +55,7 @@ TEST(MediaDataDecoder, H264)
} else {
RefPtr<MockMediaResource> resource = new MockMediaResource("gizmo.mp4");
nsresult rv = resource->Open();
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
BenchmarkRunner runner(new Benchmark(new MP4Demuxer(resource)));
EXPECT_GT(runner.Run(), 0u);
@ -73,7 +74,7 @@ TEST(MediaDataDecoder, AV1)
} else {
RefPtr<MockMediaResource> resource = new MockMediaResource("av1.mp4");
nsresult rv = resource->Open();
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
BenchmarkRunner runner(new Benchmark(new MP4Demuxer(resource)));
EXPECT_GT(runner.Run(), 0u);
@ -89,7 +90,7 @@ TEST(MediaDataDecoder, VP9)
} else {
RefPtr<MockMediaResource> resource = new MockMediaResource("vp9cake.webm");
nsresult rv = resource->Open();
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
BenchmarkRunner runner(new Benchmark(new WebMDemuxer(resource)));
EXPECT_GT(runner.Run(), 0u);

3
dom/media/gtest/mp4_demuxer/TestParser.cpp
View file

@ -7,6 +7,7 @@
#include "js/Conversions.h"
#include "MediaData.h"
#include "mozilla/ArrayUtils.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/Preferences.h"
#include "mozilla/Tuple.h"
#include "BufferStream.h"
@ -807,7 +808,7 @@ TEST_F(MP4MetadataTelemetryFixture, Telemetry) {
MP4Metadata metadata(stream);
nsresult res = metadata.Parse();
EXPECT_TRUE(NS_SUCCEEDED(res));
EXPECT_NS_SUCCEEDED(res);
auto audioTrackCount = metadata.GetNumberTracks(TrackInfo::kAudioTrack);
ASSERT_NE(audioTrackCount.Ref(), MP4Metadata::NumberTracksError());
auto videoTrackCount = metadata.GetNumberTracks(TrackInfo::kVideoTrack);

5
dom/media/mediasource/gtest/TestContainerParser.cpp
View file

@ -8,6 +8,7 @@
#include "ContainerParser.h"
#include "mozilla/ArrayUtils.h"
#include "mozilla/gtest/MozAssertions.h"
using namespace mozilla;
@ -44,7 +45,7 @@ TEST(ContainerParser, ADTSHeader)
// Test a valid header.
RefPtr<MediaByteBuffer> header = make_adts_header();
EXPECT_TRUE(NS_SUCCEEDED(parser->IsInitSegmentPresent(MediaSpan(header))));
EXPECT_NS_SUCCEEDED(parser->IsInitSegmentPresent(MediaSpan(header)));
// Test variations.
uint8_t save = header->ElementAt(1);
@ -110,7 +111,7 @@ TEST(ContainerParser, ADTSBlankMedia)
// Test the header only.
RefPtr<MediaByteBuffer> header = make_adts_header();
EXPECT_TRUE(NS_SUCCEEDED(parser->IsInitSegmentPresent(MediaSpan(header))));
EXPECT_NS_SUCCEEDED(parser->IsInitSegmentPresent(MediaSpan(header)));
// Test with the correct length of (invalid) frame data.
size_t header_length = header->Length();

23
dom/security/test/gtest/TestCSPParser.cpp
View file

@ -13,6 +13,7 @@
#include "nsNetUtil.h"
#include "mozilla/BasePrincipal.h"
#include "mozilla/dom/nsCSPContext.h"
#include "mozilla/gtest/MozAssertions.h"
#include "nsComponentManagerUtils.h"
#include "nsIPrefBranch.h"
#include "nsIPrefService.h"
@ -231,7 +232,7 @@ TEST(CSPParser, Directives)
};
uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
ASSERT_NS_SUCCEEDED(runTestSuite(policies, policyCount, 1));
}
// ============================= TestKeywords ========================
@ -258,7 +259,7 @@ TEST(CSPParser, Keywords)
};
uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
ASSERT_NS_SUCCEEDED(runTestSuite(policies, policyCount, 1));
}
// =================== TestIgnoreUpperLowerCasePolicies ==============
@ -301,7 +302,7 @@ TEST(CSPParser, IgnoreUpperLowerCasePolicies)
};
uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
ASSERT_NS_SUCCEEDED(runTestSuite(policies, policyCount, 1));
}
// ========================= TestPaths ===============================
@ -400,7 +401,7 @@ TEST(CSPParser, Paths)
};
uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
ASSERT_NS_SUCCEEDED(runTestSuite(policies, policyCount, 1));
}
// ======================== TestSimplePolicies =======================
@ -483,7 +484,7 @@ TEST(CSPParser, SimplePolicies)
};
uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
ASSERT_NS_SUCCEEDED(runTestSuite(policies, policyCount, 1));
}
// =================== TestPoliciesWithInvalidSrc ====================
@ -577,7 +578,7 @@ TEST(CSPParser, PoliciesWithInvalidSrc)
// amount of tests - 1, because the latest should be ignored.
uint32_t policyCount = (sizeof(policies) / sizeof(PolicyTest)) - 1;
ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
ASSERT_NS_SUCCEEDED(runTestSuite(policies, policyCount, 1));
}
// ============================= TestBadPolicies =======================
@ -600,7 +601,7 @@ TEST(CSPParser, BadPolicies)
};
uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 0)));
ASSERT_NS_SUCCEEDED(runTestSuite(policies, policyCount, 0));
}
// ======================= TestGoodGeneratedPolicies =================
@ -829,7 +830,7 @@ TEST(CSPParser, GoodGeneratedPolicies)
};
uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
ASSERT_NS_SUCCEEDED(runTestSuite(policies, policyCount, 1));
}
// ==================== TestBadGeneratedPolicies ====================
@ -856,7 +857,7 @@ TEST(CSPParser, BadGeneratedPolicies)
};
uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 0)));
ASSERT_NS_SUCCEEDED(runTestSuite(policies, policyCount, 0));
}
// ============ TestGoodGeneratedPoliciesForPathHandling =============
@ -980,7 +981,7 @@ TEST(CSPParser, GoodGeneratedPoliciesForPathHandling)
};
uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
ASSERT_NS_SUCCEEDED(runTestSuite(policies, policyCount, 1));
}
// ============== TestBadGeneratedPoliciesForPathHandling ============
@ -1007,7 +1008,7 @@ TEST(CSPParser, BadGeneratedPoliciesForPathHandling)
};
uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
ASSERT_NS_SUCCEEDED(runTestSuite(policies, policyCount, 1));
}
// ======================== TestFuzzyPolicies ========================

449
editor/txmgr/tests/TestTXMgr.cpp
View file

File diff suppressed because it is too large Load diff

3
gfx/tests/gtest/TestVsync.cpp
View file

@ -12,6 +12,7 @@
#include "mozilla/RefPtr.h"
#include "SoftwareVsyncSource.h"
#include "VsyncSource.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/Monitor.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/VsyncDispatcher.h"
@ -90,7 +91,7 @@ static void FlushMainThreadLoop() {
// before returning.
nsCOMPtr<nsIThread> mainThread;
nsresult rv = NS_GetMainThread(getter_AddRefs(mainThread));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = NS_OK;
bool processed = true;

6
image/test/gtest/Common.cpp
View file

@ -77,13 +77,13 @@ void ImageBenchmarkBase::SetUp() {
// Figure out how much data we have.
uint64_t length;
nsresult rv = inputStream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Write the data into a SourceBuffer.
mSourceBuffer = new SourceBuffer();
mSourceBuffer->ExpectLength(length);
rv = mSourceBuffer->AppendFromInputStream(inputStream, length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
mSourceBuffer->Complete(NS_OK);
}
@ -133,7 +133,7 @@ void SpinPendingEvents() {
do {
processed = false;
nsresult rv = mainThread->ProcessNextEvent(false, &processed);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
} while (processed);
}

5
image/test/gtest/Common.h
View file

@ -11,6 +11,7 @@
#include "gtest/gtest.h"
#include "mozilla/Attributes.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/Maybe.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/gfx/2D.h"
@ -311,7 +312,7 @@ void WithFilterPipeline(Decoder* aDecoder, Func aFunc, bool aFinish,
const Configs&... aConfigs) {
auto pipe = MakeUnique<typename detail::FilterPipeline<Configs...>::Type>();
nsresult rv = pipe->Configure(aConfigs...);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
aFunc(aDecoder, pipe.get());
@ -344,7 +345,7 @@ void AssertConfiguringPipelineFails(Decoder* aDecoder,
nsresult rv = pipe->Configure(aConfigs...);
// Callers expect configuring the pipeline to fail.
ASSERT_TRUE(NS_FAILED(rv));
ASSERT_NS_FAILED(rv);
RawAccessFrameRef currentFrame = aDecoder->GetCurrentFrameRef();
if (currentFrame) {

2
image/test/gtest/TestAnimationFrameBuffer.cpp
View file

@ -23,7 +23,7 @@ static already_AddRefed<imgFrame> CreateEmptyFrame(
nsresult rv =
frame->InitForDecoder(aSize, mozilla::gfx::SurfaceFormat::OS_RGBA, false,
Some(animParams), aCanRecycle);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
RawAccessFrameRef frameRef = frame->RawAccessRef();
// Normally the blend animation filter would set the dirty rect, but since
// we aren't producing an actual animation here, we need to fake it.

4
image/test/gtest/TestDecodeToSurface.cpp
View file

@ -88,7 +88,7 @@ static void RunDecodeToSurface(const ImageTestCase& aTestCase,
nsCOMPtr<nsIThread> thread;
nsresult rv =
NS_NewNamedThread("DecodeToSurface", getter_AddRefs(thread), nullptr);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// We run the DecodeToSurface tests off-main-thread to ensure that
// DecodeToSurface doesn't require any main-thread-only code.
@ -149,7 +149,7 @@ TEST_F(ImageDecodeToSurface, ICOMultipleSizes) {
ImageMetadata metadata;
nsresult rv = ImageOps::DecodeMetadata(
buffer, nsDependentCString(testCase.mMimeType), metadata);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
ASSERT_TRUE(metadata.HasSize());
EXPECT_EQ(testCase.mSize, metadata.GetSize().ToUnknownSize());

70
image/test/gtest/TestDecoders.cpp
View file

@ -132,13 +132,13 @@ void WithSingleChunkDecode(const ImageTestCase& aTestCase,
// Figure out how much data we have.
uint64_t length;
nsresult rv = inputStream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Write the data into a SourceBuffer.
auto sourceBuffer = MakeNotNull<RefPtr<SourceBuffer>>();
sourceBuffer->ExpectLength(length);
rv = sourceBuffer->AppendFromInputStream(inputStream, length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
sourceBuffer->Complete(NS_OK);
// Create a decoder.
@ -182,7 +182,7 @@ void WithDelayedChunkDecode(const ImageTestCase& aTestCase,
// Figure out how much data we have.
uint64_t length;
nsresult rv = inputStream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Prepare an empty SourceBuffer.
auto sourceBuffer = MakeNotNull<RefPtr<SourceBuffer>>();
@ -203,7 +203,7 @@ void WithDelayedChunkDecode(const ImageTestCase& aTestCase,
// Writing all of the data should wake up the decoder to complete.
sourceBuffer->ExpectLength(length);
rv = sourceBuffer->AppendFromInputStream(inputStream, length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
sourceBuffer->Complete(NS_OK);
// It would have gotten posted to the main thread to avoid mutex contention.
@ -227,7 +227,7 @@ static void CheckDecoderMultiChunk(const ImageTestCase& aTestCase,
// Figure out how much data we have.
uint64_t length;
nsresult rv = inputStream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Create a SourceBuffer and a decoder.
auto sourceBuffer = MakeNotNull<RefPtr<SourceBuffer>>();
@ -251,11 +251,11 @@ static void CheckDecoderMultiChunk(const ImageTestCase& aTestCase,
uint64_t available = 0;
rv = inputStream->Available(&available);
ASSERT_TRUE(available >= read);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Writing any data should wake up the decoder to complete.
rv = sourceBuffer->AppendFromInputStream(inputStream, read);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// It would have gotten posted to the main thread to avoid mutex contention.
SpinPendingEvents();
@ -333,7 +333,7 @@ static void CheckAnimationDecoderResults(const ImageTestCase& aTestCase,
DrawableSurface drawableSurface(WrapNotNull(aProvider));
for (size_t i = 0; i < framePixels.Length(); ++i) {
nsresult rv = drawableSurface.Seek(i);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
// Check the first frame, all green.
RawAccessFrameRef rawFrame = drawableSurface->RawAccessRef();
@ -349,7 +349,7 @@ static void CheckAnimationDecoderResults(const ImageTestCase& aTestCase,
// Should be no more frames.
nsresult rv = drawableSurface.Seek(framePixels.Length());
EXPECT_TRUE(NS_FAILED(rv));
EXPECT_NS_FAILED(rv);
}
template <typename Func>
@ -369,13 +369,13 @@ static void WithSingleChunkAnimationDecode(const ImageTestCase& aTestCase,
// Figure out how much data we have.
uint64_t length;
nsresult rv = inputStream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Write the data into a SourceBuffer.
NotNull<RefPtr<SourceBuffer>> sourceBuffer = WrapNotNull(new SourceBuffer());
sourceBuffer->ExpectLength(length);
rv = sourceBuffer->AppendFromInputStream(inputStream, length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
sourceBuffer->Complete(NS_OK);
// Create a metadata decoder first, because otherwise RasterImage will get
@ -435,16 +435,16 @@ static void CheckDecoderFrameFirst(const ImageTestCase& aTestCase) {
// Figure out how much data we have.
uint64_t length;
nsresult rv = inputStream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Write the data into the image.
rv = image->OnImageDataAvailable(nullptr, inputStream, 0,
static_cast<uint32_t>(length));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Let the image know we've sent all the data.
rv = image->OnImageDataComplete(nullptr, NS_OK, true);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
RefPtr<ProgressTracker> tracker = image->GetProgressTracker();
tracker->SyncNotifyProgress(FLAG_LOAD_COMPLETE);
@ -462,9 +462,9 @@ static void CheckDecoderFrameFirst(const ImageTestCase& aTestCase) {
// Ensure that the image's metadata meets our expectations.
IntSize imageSize(0, 0);
rv = image->GetWidth(&imageSize.width);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
rv = image->GetHeight(&imageSize.height);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
EXPECT_EQ(aTestCase.mSize.width, imageSize.width);
EXPECT_EQ(aTestCase.mSize.height, imageSize.height);
@ -509,7 +509,7 @@ static void CheckDecoderFrameFirst(const ImageTestCase& aTestCase) {
/* aMarkUsed = */ true);
ASSERT_EQ(MatchType::EXACT, result.Type());
EXPECT_TRUE(NS_SUCCEEDED(result.Surface().Seek(0)));
EXPECT_NS_SUCCEEDED(result.Surface().Seek(0));
EXPECT_TRUE(bool(result.Surface()));
RefPtr<imgFrame> partialFrame = result.Surface().GetFrame(1);
@ -545,16 +545,16 @@ static void CheckDecoderFrameCurrent(const ImageTestCase& aTestCase) {
// Figure out how much data we have.
uint64_t length;
nsresult rv = inputStream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Write the data into the image.
rv = image->OnImageDataAvailable(nullptr, inputStream, 0,
static_cast<uint32_t>(length));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Let the image know we've sent all the data.
rv = image->OnImageDataComplete(nullptr, NS_OK, true);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
RefPtr<ProgressTracker> tracker = image->GetProgressTracker();
tracker->SyncNotifyProgress(FLAG_LOAD_COMPLETE);
@ -570,9 +570,9 @@ static void CheckDecoderFrameCurrent(const ImageTestCase& aTestCase) {
// Ensure that the image's metadata meets our expectations.
IntSize imageSize(0, 0);
rv = image->GetWidth(&imageSize.width);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
rv = image->GetHeight(&imageSize.height);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
EXPECT_EQ(aTestCase.mSize.width, imageSize.width);
EXPECT_EQ(aTestCase.mSize.height, imageSize.height);
@ -591,7 +591,7 @@ static void CheckDecoderFrameCurrent(const ImageTestCase& aTestCase) {
/* aMarkUsed = */ true);
ASSERT_EQ(MatchType::EXACT, result.Type());
EXPECT_TRUE(NS_SUCCEEDED(result.Surface().Seek(0)));
EXPECT_NS_SUCCEEDED(result.Surface().Seek(0));
EXPECT_TRUE(bool(result.Surface()));
RefPtr<imgFrame> partialFrame = result.Surface().GetFrame(1);
@ -633,7 +633,7 @@ static void CheckDecoderFrameCurrent(const ImageTestCase& aTestCase) {
/* aMarkUsed = */ true);
ASSERT_EQ(MatchType::EXACT, result.Type());
EXPECT_TRUE(NS_SUCCEEDED(result.Surface().Seek(0)));
EXPECT_NS_SUCCEEDED(result.Surface().Seek(0));
EXPECT_TRUE(bool(result.Surface()));
RefPtr<imgFrame> partialFrame = result.Surface().GetFrame(1);
@ -984,9 +984,9 @@ TEST_F(ImageDecoders, AnimatedGIFWithExtraImageSubBlocks) {
// Ensure that the image's metadata meets our expectations.
IntSize imageSize(0, 0);
nsresult rv = image->GetWidth(&imageSize.width);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
rv = image->GetHeight(&imageSize.height);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
EXPECT_EQ(testCase.mSize.width, imageSize.width);
EXPECT_EQ(testCase.mSize.height, imageSize.height);
@ -1005,7 +1005,7 @@ TEST_F(ImageDecoders, AnimatedGIFWithExtraImageSubBlocks) {
/* aMarkUsed = */ true);
ASSERT_EQ(MatchType::EXACT, result.Type());
EXPECT_TRUE(NS_SUCCEEDED(result.Surface().Seek(0)));
EXPECT_NS_SUCCEEDED(result.Surface().Seek(0));
EXPECT_TRUE(bool(result.Surface()));
RefPtr<imgFrame> partialFrame = result.Surface().GetFrame(1);
@ -1054,16 +1054,16 @@ TEST_F(ImageDecoders, MultipleSizesICOSingleChunk) {
// Figure out how much data we have.
uint64_t length;
nsresult rv = inputStream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Write the data into the image.
rv = image->OnImageDataAvailable(nullptr, inputStream, 0,
static_cast<uint32_t>(length));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Let the image know we've sent all the data.
rv = image->OnImageDataComplete(nullptr, NS_OK, true);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
RefPtr<ProgressTracker> tracker = image->GetProgressTracker();
tracker->SyncNotifyProgress(FLAG_LOAD_COMPLETE);
@ -1075,16 +1075,16 @@ TEST_F(ImageDecoders, MultipleSizesICOSingleChunk) {
// Ensure that the image's metadata meets our expectations.
IntSize imageSize(0, 0);
rv = image->GetWidth(&imageSize.width);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
rv = image->GetHeight(&imageSize.height);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
EXPECT_EQ(testCase.mSize.width, imageSize.width);
EXPECT_EQ(testCase.mSize.height, imageSize.height);
nsTArray<IntSize> nativeSizes;
rv = image->GetNativeSizes(nativeSizes);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
ASSERT_EQ(6u, nativeSizes.Length());
IntSize expectedSizes[] = {IntSize(16, 16), IntSize(32, 32),
@ -1098,7 +1098,7 @@ TEST_F(ImageDecoders, MultipleSizesICOSingleChunk) {
RefPtr<Image> image90 =
ImageOps::Orient(image, Orientation(Angle::D90, Flip::Unflipped));
rv = image90->GetNativeSizes(nativeSizes);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
ASSERT_EQ(6u, nativeSizes.Length());
for (int i = 0; i < 5; ++i) {
@ -1109,7 +1109,7 @@ TEST_F(ImageDecoders, MultipleSizesICOSingleChunk) {
RefPtr<Image> image180 =
ImageOps::Orient(image, Orientation(Angle::D180, Flip::Unflipped));
rv = image180->GetNativeSizes(nativeSizes);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
ASSERT_EQ(6u, nativeSizes.Length());
for (int i = 0; i < 6; ++i) {

4
image/test/gtest/TestFrameAnimator.cpp
View file

@ -61,13 +61,13 @@ static void WithFrameAnimatorDecode(const ImageTestCase& aTestCase,
// Figure out how much data we have.
uint64_t length;
nsresult rv = inputStream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Write the data into a SourceBuffer.
NotNull<RefPtr<SourceBuffer>> sourceBuffer = WrapNotNull(new SourceBuffer());
sourceBuffer->ExpectLength(length);
rv = sourceBuffer->AppendFromInputStream(inputStream, length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
sourceBuffer->Complete(NS_OK);
// Create a metadata decoder first, because otherwise RasterImage will get

4
image/test/gtest/TestLoader.cpp
View file

@ -19,10 +19,10 @@ static void CheckMimeType(const char* aContents, size_t aLength,
nsAutoCString detected;
nsresult rv = imgLoader::GetMimeTypeFromContent(aContents, aLength, detected);
if (aExpected) {
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
EXPECT_TRUE(detected.EqualsASCII(aExpected));
} else {
ASSERT_TRUE(NS_FAILED(rv));
ASSERT_NS_FAILED(rv);
EXPECT_TRUE(detected.IsEmpty());
}
}

16
image/test/gtest/TestMetadata.cpp
View file

@ -36,13 +36,13 @@ static void CheckMetadata(const ImageTestCase& aTestCase,
// Figure out how much data we have.
uint64_t length;
nsresult rv = inputStream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Write the data into a SourceBuffer.
auto sourceBuffer = MakeNotNull<RefPtr<SourceBuffer>>();
sourceBuffer->ExpectLength(length);
rv = sourceBuffer->AppendFromInputStream(inputStream, length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
sourceBuffer->Complete(NS_OK);
// Create a metadata decoder.
@ -211,16 +211,16 @@ TEST_F(ImageDecoderMetadata, NoFrameDelayGIFFullDecode) {
// Figure out how much data we have.
uint64_t length;
nsresult rv = inputStream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Write the data into the image.
rv = image->OnImageDataAvailable(nullptr, inputStream, 0,
static_cast<uint32_t>(length));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Let the image know we've sent all the data.
rv = image->OnImageDataComplete(nullptr, NS_OK, true);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
RefPtr<ProgressTracker> tracker = image->GetProgressTracker();
tracker->SyncNotifyProgress(FLAG_LOAD_COMPLETE);
@ -232,9 +232,9 @@ TEST_F(ImageDecoderMetadata, NoFrameDelayGIFFullDecode) {
// Ensure that the image's metadata meets our expectations.
IntSize imageSize(0, 0);
rv = image->GetWidth(&imageSize.width);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
rv = image->GetHeight(&imageSize.height);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
EXPECT_EQ(testCase.mSize.width, imageSize.width);
EXPECT_EQ(testCase.mSize.height, imageSize.height);
@ -252,7 +252,7 @@ TEST_F(ImageDecoderMetadata, NoFrameDelayGIFFullDecode) {
/* aMarkUsed = */ true);
ASSERT_EQ(MatchType::EXACT, result.Type());
EXPECT_TRUE(NS_SUCCEEDED(result.Surface().Seek(0)));
EXPECT_NS_SUCCEEDED(result.Surface().Seek(0));
EXPECT_TRUE(bool(result.Surface()));
RefPtr<imgFrame> partialFrame = result.Surface().GetFrame(1);

18
image/test/gtest/TestSourceBuffer.cpp
View file

@ -69,7 +69,7 @@ class ImageSourceBuffer : public ::testing::Test {
protected:
void CheckedAppendToBuffer(const char* aData, size_t aLength) {
EXPECT_TRUE(NS_SUCCEEDED(mSourceBuffer->Append(aData, aLength)));
EXPECT_NS_SUCCEEDED(mSourceBuffer->Append(aData, aLength));
}
void CheckedAppendToBufferLastByteForLength(size_t aLength) {
@ -236,7 +236,7 @@ TEST_F(ImageSourceBuffer, Append) {
SourceBufferIterator iterator = mSourceBuffer->Iterator();
// Write test data to the buffer.
EXPECT_TRUE(NS_SUCCEEDED(mSourceBuffer->ExpectLength(sizeof(mData))));
EXPECT_NS_SUCCEEDED(mSourceBuffer->ExpectLength(sizeof(mData)));
CheckedAppendToBuffer(mData, sizeof(mData));
CheckedCompleteBuffer(iterator, sizeof(mData));
@ -258,7 +258,7 @@ TEST_F(ImageSourceBuffer, HugeAppendFails) {
// Attempt to write a massive amount of data and verify that it fails. (We'd
// get a buffer overrun during the test if it succeeds, but if it succeeds
// that's the least of our problems.)
EXPECT_TRUE(NS_FAILED(mSourceBuffer->Append(mData, hugeSize)));
EXPECT_NS_FAILED(mSourceBuffer->Append(mData, hugeSize));
EXPECT_TRUE(mSourceBuffer->IsComplete());
CheckIteratorIsComplete(iterator, 0, 0, NS_ERROR_OUT_OF_MEMORY);
}
@ -273,7 +273,7 @@ TEST_F(ImageSourceBuffer, AppendFromInputStream) {
// Figure out how much data we have.
uint64_t length;
ASSERT_TRUE(NS_SUCCEEDED(inputStream->Available(&length)));
ASSERT_NS_SUCCEEDED(inputStream->Available(&length));
// Write test data to the buffer.
EXPECT_TRUE(
@ -289,7 +289,7 @@ TEST_F(ImageSourceBuffer, AppendAfterComplete) {
SourceBufferIterator iterator = mSourceBuffer->Iterator();
// Write test data to the buffer.
EXPECT_TRUE(NS_SUCCEEDED(mSourceBuffer->ExpectLength(sizeof(mData))));
EXPECT_NS_SUCCEEDED(mSourceBuffer->ExpectLength(sizeof(mData)));
CheckedAppendToBuffer(mData, sizeof(mData));
CheckedCompleteBuffer(iterator, sizeof(mData));
@ -299,7 +299,7 @@ TEST_F(ImageSourceBuffer, AppendAfterComplete) {
CheckIteratorIsComplete(iterator, sizeof(mData));
// Write more data to the completed buffer.
EXPECT_TRUE(NS_FAILED(mSourceBuffer->Append(mData, sizeof(mData))));
EXPECT_NS_FAILED(mSourceBuffer->Append(mData, sizeof(mData)));
// Try to read with a new iterator and verify that the new data got ignored.
SourceBufferIterator iterator2 = mSourceBuffer->Iterator();
@ -337,7 +337,7 @@ TEST_F(ImageSourceBuffer, ExpectLengthAllocatesRequestedCapacity) {
// byte. We expect this to still result in two chunks, because we trust the
// initial guess of ExpectLength() but after that it will only allocate chunks
// of at least MIN_CHUNK_CAPACITY bytes.
EXPECT_TRUE(NS_SUCCEEDED(mSourceBuffer->ExpectLength(1)));
EXPECT_NS_SUCCEEDED(mSourceBuffer->ExpectLength(1));
CheckedAppendToBufferInChunks(10, SourceBuffer::MIN_CHUNK_CAPACITY);
CheckedCompleteBuffer(iterator, SourceBuffer::MIN_CHUNK_CAPACITY);
@ -357,7 +357,7 @@ TEST_F(ImageSourceBuffer, ExpectLengthGrowsAboveMinCapacity) {
// this to result in only one chunk, because ExpectLength() allows us to
// allocate a larger first chunk than MIN_CHUNK_CAPACITY bytes.
const size_t length = 2 * SourceBuffer::MIN_CHUNK_CAPACITY;
EXPECT_TRUE(NS_SUCCEEDED(mSourceBuffer->ExpectLength(length)));
EXPECT_NS_SUCCEEDED(mSourceBuffer->ExpectLength(length));
CheckedAppendToBufferInChunks(10, length);
// Verify that the iterator sees a single chunk.
@ -386,7 +386,7 @@ TEST_F(ImageSourceBuffer, HugeExpectLengthFails) {
// Attempt to write a massive amount of data and verify that it fails. (We'd
// get a buffer overrun during the test if it succeeds, but if it succeeds
// that's the least of our problems.)
EXPECT_TRUE(NS_FAILED(mSourceBuffer->ExpectLength(hugeSize)));
EXPECT_NS_FAILED(mSourceBuffer->ExpectLength(hugeSize));
EXPECT_TRUE(mSourceBuffer->IsComplete());
CheckIteratorIsComplete(iterator, 0, 0, NS_ERROR_INVALID_ARG);
}

6
image/test/gtest/TestSurfaceCache.cpp
View file

@ -38,7 +38,7 @@ TEST_F(ImageSurfaceCache, Factor2) {
// Figure out how much data we have.
uint64_t length;
nsresult rv = inputStream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Ensures we meet the threshold for FLAG_SYNC_DECODE_IF_FAST to do sync
// decoding without the implications of FLAG_SYNC_DECODE.
@ -49,11 +49,11 @@ TEST_F(ImageSurfaceCache, Factor2) {
// Write the data into the image.
rv = image->OnImageDataAvailable(nullptr, inputStream, 0,
static_cast<uint32_t>(length));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Let the image know we've sent all the data.
rv = image->OnImageDataComplete(nullptr, NS_OK, true);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
RefPtr<ProgressTracker> tracker = image->GetProgressTracker();
tracker->SyncNotifyProgress(FLAG_LOAD_COMPLETE);

2
image/test/gtest/TestSurfacePipeIntegration.cpp
View file

@ -99,7 +99,7 @@ TEST_F(ImageSurfacePipeIntegration, SurfacePipe) {
auto sink = MakeUnique<SurfaceSink>();
nsresult rv = sink->Configure(
SurfaceConfig{decoder, IntSize(100, 100), SurfaceFormat::OS_RGBA, false});
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
pipe = TestSurfacePipeFactory::SurfacePipeFromPipeline(sink);

49
intl/locale/tests/gtest/TestAppDateTimeFormat.cpp
View file

@ -1,4 +1,5 @@
#include "gtest/gtest.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/intl/AppDateTimeFormat.h"
#include "mozilla/intl/DateTimeFormat.h"
@ -28,7 +29,7 @@ TEST(AppDateTimeFormat, FormatPRExplodedTime)
nsAutoString formattedTime;
nsresult rv =
AppDateTimeFormat::Format(style, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(formattedTime.Find(u"January") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"1970") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"12:00:00 AM") != kNotFound ||
@ -38,7 +39,7 @@ TEST(AppDateTimeFormat, FormatPRExplodedTime)
rv = AppDateTimeFormat::Format(style, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(formattedTime.Find(u"January") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"1970") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"12:19:00 AM") != kNotFound ||
@ -47,7 +48,7 @@ TEST(AppDateTimeFormat, FormatPRExplodedTime)
prExplodedTime = {0, 0, 0, 7, 1,
0, 1970, 4, 0, {(6 * 60 * 60), (1 * 60 * 60)}};
rv = AppDateTimeFormat::Format(style, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(formattedTime.Find(u"January") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"1970") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"7:00:00 AM") != kNotFound ||
@ -57,7 +58,7 @@ TEST(AppDateTimeFormat, FormatPRExplodedTime)
0, 0, 29, 11, 1,
0, 1970, 4, 0, {(10 * 60 * 60) + (29 * 60), (1 * 60 * 60)}};
rv = AppDateTimeFormat::Format(style, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(formattedTime.Find(u"January") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"1970") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"11:29:00 AM") != kNotFound ||
@ -65,7 +66,7 @@ TEST(AppDateTimeFormat, FormatPRExplodedTime)
prExplodedTime = {0, 0, 37, 23, 31, 11, 1969, 3, 364, {-(23 * 60), 0}};
rv = AppDateTimeFormat::Format(style, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(formattedTime.Find(u"December") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"31") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"1969") != kNotFound);
@ -74,7 +75,7 @@ TEST(AppDateTimeFormat, FormatPRExplodedTime)
prExplodedTime = {0, 0, 0, 17, 31, 11, 1969, 3, 364, {-(7 * 60 * 60), 0}};
rv = AppDateTimeFormat::Format(style, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(formattedTime.Find(u"December") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"31") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"1969") != kNotFound);
@ -85,7 +86,7 @@ TEST(AppDateTimeFormat, FormatPRExplodedTime)
0, 0, 47, 14, 31,
11, 1969, 3, 364, {-((10 * 60 * 60) + (13 * 60)), (1 * 60 * 60)}};
rv = AppDateTimeFormat::Format(style, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(formattedTime.Find(u"December") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"31") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"1969") != kNotFound);
@ -111,7 +112,7 @@ TEST(AppDateTimeFormat, DateFormatSelectors)
nsresult rv =
AppDateTimeFormat::Format(components, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_STREQ("01/1970", NS_ConvertUTF16toUTF8(formattedTime).get());
}
{
@ -121,7 +122,7 @@ TEST(AppDateTimeFormat, DateFormatSelectors)
nsresult rv =
AppDateTimeFormat::Format(components, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_STREQ("January 1970", NS_ConvertUTF16toUTF8(formattedTime).get());
}
{
@ -130,7 +131,7 @@ TEST(AppDateTimeFormat, DateFormatSelectors)
nsresult rv =
AppDateTimeFormat::Format(components, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_STREQ("January", NS_ConvertUTF16toUTF8(formattedTime).get());
}
{
@ -139,7 +140,7 @@ TEST(AppDateTimeFormat, DateFormatSelectors)
nsresult rv =
AppDateTimeFormat::Format(components, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_STREQ("Thu", NS_ConvertUTF16toUTF8(formattedTime).get());
}
}
@ -157,7 +158,7 @@ TEST(AppDateTimeFormat, FormatPRExplodedTimeForeign)
nsAutoString formattedTime;
nsresult rv =
AppDateTimeFormat::Format(style, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(formattedTime.Find(u"1.") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"Januar") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"1970") != kNotFound);
@ -166,7 +167,7 @@ TEST(AppDateTimeFormat, FormatPRExplodedTimeForeign)
prExplodedTime = {0, 0, 19, 0, 1, 0, 1970, 4, 0, {(19 * 60), 0}};
rv = AppDateTimeFormat::Format(style, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(formattedTime.Find(u"1.") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"Januar") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"1970") != kNotFound);
@ -176,7 +177,7 @@ TEST(AppDateTimeFormat, FormatPRExplodedTimeForeign)
prExplodedTime = {0, 0, 0, 7, 1,
0, 1970, 4, 0, {(6 * 60 * 60), (1 * 60 * 60)}};
rv = AppDateTimeFormat::Format(style, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(formattedTime.Find(u"1.") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"Januar") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"1970") != kNotFound);
@ -187,7 +188,7 @@ TEST(AppDateTimeFormat, FormatPRExplodedTimeForeign)
0, 0, 29, 11, 1,
0, 1970, 4, 0, {(10 * 60 * 60) + (29 * 60), (1 * 60 * 60)}};
rv = AppDateTimeFormat::Format(style, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(formattedTime.Find(u"1.") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"Januar") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"1970") != kNotFound);
@ -196,7 +197,7 @@ TEST(AppDateTimeFormat, FormatPRExplodedTimeForeign)
prExplodedTime = {0, 0, 37, 23, 31, 11, 1969, 3, 364, {-(23 * 60), 0}};
rv = AppDateTimeFormat::Format(style, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(formattedTime.Find(u"31.") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"Dezember") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"1969") != kNotFound);
@ -205,7 +206,7 @@ TEST(AppDateTimeFormat, FormatPRExplodedTimeForeign)
prExplodedTime = {0, 0, 0, 17, 31, 11, 1969, 3, 364, {-(7 * 60 * 60), 0}};
rv = AppDateTimeFormat::Format(style, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(formattedTime.Find(u"31.") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"Dezember") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"1969") != kNotFound);
@ -216,7 +217,7 @@ TEST(AppDateTimeFormat, FormatPRExplodedTimeForeign)
0, 0, 47, 14, 31,
11, 1969, 3, 364, {-((10 * 60 * 60) + (13 * 60)), (1 * 60 * 60)}};
rv = AppDateTimeFormat::Format(style, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(formattedTime.Find(u"31.") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"Dezember") != kNotFound);
ASSERT_TRUE(formattedTime.Find(u"1969") != kNotFound);
@ -241,7 +242,7 @@ TEST(AppDateTimeFormat, DateFormatSelectorsForeign)
nsresult rv =
AppDateTimeFormat::Format(components, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_STREQ("01.1970", NS_ConvertUTF16toUTF8(formattedTime).get());
}
{
@ -251,7 +252,7 @@ TEST(AppDateTimeFormat, DateFormatSelectorsForeign)
nsresult rv =
AppDateTimeFormat::Format(components, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_STREQ("Januar 1970", NS_ConvertUTF16toUTF8(formattedTime).get());
}
{
@ -260,7 +261,7 @@ TEST(AppDateTimeFormat, DateFormatSelectorsForeign)
nsresult rv =
AppDateTimeFormat::Format(components, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_STREQ("Do", NS_ConvertUTF16toUTF8(formattedTime).get());
}
{
@ -269,7 +270,7 @@ TEST(AppDateTimeFormat, DateFormatSelectorsForeign)
nsresult rv =
AppDateTimeFormat::Format(components, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_STREQ("Donnerstag", NS_ConvertUTF16toUTF8(formattedTime).get());
}
{
@ -278,7 +279,7 @@ TEST(AppDateTimeFormat, DateFormatSelectorsForeign)
nsresult rv =
AppDateTimeFormat::Format(components, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_STREQ("Januar", NS_ConvertUTF16toUTF8(formattedTime).get());
}
{
@ -287,7 +288,7 @@ TEST(AppDateTimeFormat, DateFormatSelectorsForeign)
nsresult rv =
AppDateTimeFormat::Format(components, &prExplodedTime, formattedTime);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_STREQ("Do", NS_ConvertUTF16toUTF8(formattedTime).get());
}
}

17
intl/locale/tests/gtest/TestOSPreferences.cpp
View file

@ -5,6 +5,7 @@
#include "gtest/gtest.h"
#include "mozilla/ArrayUtils.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/Preferences.h"
#include "mozilla/intl/OSPreferences.h"
@ -126,14 +127,14 @@ TEST(Intl_Locale_OSPreferences, GetDateTimePatternPrefOverrides)
nr = osprefs->GetDateTimePattern(config.DateTimeFormatStyle,
mozIOSPreferences::dateTimeFormatStyleNone,
nsDependentCString(""), default_pattern);
ASSERT_TRUE(NS_SUCCEEDED(nr));
ASSERT_NS_SUCCEEDED(nr);
// Override date format
mozilla::Preferences::SetCString(config.DatePref, "yy-MM");
nr = osprefs->GetDateTimePattern(config.DateTimeFormatStyle,
mozIOSPreferences::dateTimeFormatStyleNone,
nsDependentCString(""), pattern);
ASSERT_TRUE(NS_SUCCEEDED(nr));
ASSERT_NS_SUCCEEDED(nr);
ASSERT_TRUE(pattern.EqualsASCII("yy-MM"));
// Override time format
@ -141,14 +142,14 @@ TEST(Intl_Locale_OSPreferences, GetDateTimePatternPrefOverrides)
nr = osprefs->GetDateTimePattern(mozIOSPreferences::dateTimeFormatStyleNone,
config.DateTimeFormatStyle,
nsDependentCString(""), pattern);
ASSERT_TRUE(NS_SUCCEEDED(nr));
ASSERT_NS_SUCCEEDED(nr);
ASSERT_TRUE(pattern.EqualsASCII("HH:mm"));
// Override both
nr = osprefs->GetDateTimePattern(config.DateTimeFormatStyle,
config.DateTimeFormatStyle,
nsDependentCString(""), pattern);
ASSERT_TRUE(NS_SUCCEEDED(nr));
ASSERT_NS_SUCCEEDED(nr);
ASSERT_TRUE(pattern.Find("yy-MM") != kNotFound);
ASSERT_TRUE(pattern.Find("HH:mm") != kNotFound);
@ -158,7 +159,7 @@ TEST(Intl_Locale_OSPreferences, GetDateTimePatternPrefOverrides)
nr = osprefs->GetDateTimePattern(config.DateTimeFormatStyle,
mozIOSPreferences::dateTimeFormatStyleNone,
nsDependentCString(""), pattern);
ASSERT_TRUE(NS_SUCCEEDED(nr));
ASSERT_NS_SUCCEEDED(nr);
ASSERT_EQ(default_pattern, pattern);
}
@ -176,7 +177,7 @@ TEST(Intl_Locale_OSPreferences, GetDateTimePatternPrefOverrides)
nr = osprefs->GetDateTimePattern(mozIOSPreferences::dateTimeFormatStyleShort,
mozIOSPreferences::dateTimeFormatStyleShort,
nsDependentCString(""), pattern);
ASSERT_TRUE(NS_SUCCEEDED(nr));
ASSERT_NS_SUCCEEDED(nr);
ASSERT_TRUE(pattern.EqualsASCII("yyyy-MM-dd HH:mm:ss"));
// Reset to date and time to defaults
@ -189,7 +190,7 @@ TEST(Intl_Locale_OSPreferences, GetDateTimePatternPrefOverrides)
nr = osprefs->GetDateTimePattern(mozIOSPreferences::dateTimeFormatStyleShort,
mozIOSPreferences::dateTimeFormatStyleShort,
nsDependentCString(""), pattern);
ASSERT_TRUE(NS_SUCCEEDED(nr));
ASSERT_NS_SUCCEEDED(nr);
ASSERT_EQ(default_pattern, pattern);
// Clearing the override results in getting the default pattern back.
@ -198,6 +199,6 @@ TEST(Intl_Locale_OSPreferences, GetDateTimePatternPrefOverrides)
nr = osprefs->GetDateTimePattern(mozIOSPreferences::dateTimeFormatStyleShort,
mozIOSPreferences::dateTimeFormatStyleShort,
nsDependentCString(""), pattern);
ASSERT_TRUE(NS_SUCCEEDED(nr));
ASSERT_NS_SUCCEEDED(nr);
ASSERT_EQ(default_pattern, pattern);
}

55
ipc/gtest/TestDataPipe.cpp
View file

@ -7,6 +7,7 @@
#include "chrome/common/ipc_message.h"
#include "gtest/gtest.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/ipc/DataPipe.h"
#include "nsIAsyncInputStream.h"
#include "nsIAsyncOutputStream.h"
@ -94,7 +95,7 @@ void ConsumeAndValidateStream(nsIInputStream* aStream,
const nsACString& aExpectedData) {
nsAutoCString outputData;
nsresult rv = NS_ConsumeStream(aStream, UINT32_MAX, outputData);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(aExpectedData.Length(), outputData.Length());
ASSERT_TRUE(aExpectedData.Equals(outputData));
}
@ -108,7 +109,7 @@ TEST(DataPipe, SegmentedReadWrite)
nsresult rv =
NewDataPipe(1024, getter_AddRefs(writer), getter_AddRefs(reader));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCString inputData1;
CreateData(512, inputData1);
@ -116,7 +117,7 @@ TEST(DataPipe, SegmentedReadWrite)
uint32_t numWritten = 0;
rv = writer->Write(inputData1.BeginReading(), inputData1.Length(),
&numWritten);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
EXPECT_EQ(numWritten, 512u);
uint64_t available = 0;
@ -129,7 +130,7 @@ TEST(DataPipe, SegmentedReadWrite)
rv = writer->Write(inputData2.BeginReading(), inputData2.Length(),
&numWritten);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
EXPECT_EQ(numWritten, 1024u);
rv = reader->Available(&available);
@ -144,7 +145,7 @@ TEST(DataPipe, SegmentedPartialRead)
nsresult rv =
NewDataPipe(1024, getter_AddRefs(writer), getter_AddRefs(reader));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCString inputData1;
CreateData(512, inputData1);
@ -152,7 +153,7 @@ TEST(DataPipe, SegmentedPartialRead)
uint32_t numWritten = 0;
rv = writer->Write(inputData1.BeginReading(), inputData1.Length(),
&numWritten);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
EXPECT_EQ(numWritten, 512u);
uint64_t available = 0;
@ -165,7 +166,7 @@ TEST(DataPipe, SegmentedPartialRead)
rv = writer->Write(inputData2.BeginReading(), inputData2.Length(),
&numWritten);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
EXPECT_EQ(numWritten, 1024u);
rv = reader->Available(&available);
@ -173,7 +174,7 @@ TEST(DataPipe, SegmentedPartialRead)
nsAutoCString outputData;
rv = NS_ReadInputStreamToString(reader, outputData, 768);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(768u, outputData.Length());
ASSERT_TRUE(Substring(inputData2, 0, 768).Equals(outputData));
@ -182,7 +183,7 @@ TEST(DataPipe, SegmentedPartialRead)
nsAutoCString outputData2;
rv = NS_ReadInputStreamToString(reader, outputData2, 256);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(256u, outputData2.Length());
ASSERT_TRUE(Substring(inputData2, 768).Equals(outputData2));
}
@ -196,14 +197,14 @@ TEST(DataPipe, Write_AsyncWait)
nsresult rv =
NewDataPipe(segmentSize, getter_AddRefs(writer), getter_AddRefs(reader));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCString inputData;
CreateData(segmentSize, inputData);
uint32_t numWritten = 0;
rv = writer->Write(inputData.BeginReading(), inputData.Length(), &numWritten);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
EXPECT_EQ(numWritten, segmentSize);
rv = writer->Write(inputData.BeginReading(), inputData.Length(), &numWritten);
@ -212,7 +213,7 @@ TEST(DataPipe, Write_AsyncWait)
RefPtr<OutputStreamCallback> cb = new OutputStreamCallback();
rv = writer->AsyncWait(cb, 0, 0, GetCurrentSerialEventTarget());
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
NS_ProcessPendingEvents(nullptr);
@ -236,7 +237,7 @@ TEST(DataPipe, Read_AsyncWait)
nsresult rv =
NewDataPipe(segmentSize, getter_AddRefs(writer), getter_AddRefs(reader));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCString inputData;
CreateData(segmentSize, inputData);
@ -244,7 +245,7 @@ TEST(DataPipe, Read_AsyncWait)
RefPtr<InputStreamCallback> cb = new InputStreamCallback();
rv = reader->AsyncWait(cb, 0, 0, GetCurrentSerialEventTarget());
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
NS_ProcessPendingEvents(nullptr);
@ -252,7 +253,7 @@ TEST(DataPipe, Read_AsyncWait)
uint32_t numWritten = 0;
rv = writer->Write(inputData.BeginReading(), inputData.Length(), &numWritten);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_FALSE(cb->Called());
@ -272,14 +273,14 @@ TEST(DataPipe, Write_AsyncWait_Cancel)
nsresult rv =
NewDataPipe(segmentSize, getter_AddRefs(writer), getter_AddRefs(reader));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCString inputData;
CreateData(segmentSize, inputData);
uint32_t numWritten = 0;
rv = writer->Write(inputData.BeginReading(), inputData.Length(), &numWritten);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
EXPECT_EQ(numWritten, segmentSize);
rv = writer->Write(inputData.BeginReading(), inputData.Length(), &numWritten);
@ -289,9 +290,9 @@ TEST(DataPipe, Write_AsyncWait_Cancel)
// Register a callback and immediately cancel it.
rv = writer->AsyncWait(cb, 0, 0, GetCurrentSerialEventTarget());
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = writer->AsyncWait(nullptr, 0, 0, nullptr);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Even after consuming the stream and processing pending events, the callback
// shouldn't be called as it was cancelled.
@ -309,7 +310,7 @@ TEST(DataPipe, Read_AsyncWait_Cancel)
nsresult rv =
NewDataPipe(segmentSize, getter_AddRefs(writer), getter_AddRefs(reader));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCString inputData;
CreateData(segmentSize, inputData);
@ -318,15 +319,15 @@ TEST(DataPipe, Read_AsyncWait_Cancel)
// Register a callback and immediately cancel it.
rv = reader->AsyncWait(cb, 0, 0, GetCurrentSerialEventTarget());
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = reader->AsyncWait(nullptr, 0, 0, nullptr);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Write data into the pipe to make the callback become ready.
uint32_t numWritten = 0;
rv = writer->Write(inputData.BeginReading(), inputData.Length(), &numWritten);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Even after processing pending events, the callback shouldn't be called as
// it was cancelled.
@ -342,7 +343,7 @@ TEST(DataPipe, SerializeReader)
RefPtr<DataPipeSender> writer;
nsresult rv =
NewDataPipe(1024, getter_AddRefs(writer), getter_AddRefs(reader));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
IPC::Message msg(MSG_ROUTING_NONE, 0);
IPC::MessageWriter msgWriter(msg);
@ -350,14 +351,14 @@ TEST(DataPipe, SerializeReader)
uint64_t available = 0;
rv = reader->Available(&available);
ASSERT_TRUE(NS_FAILED(rv));
ASSERT_NS_FAILED(rv);
nsCString inputData;
CreateData(512, inputData);
uint32_t numWritten = 0;
rv = writer->Write(inputData.BeginReading(), inputData.Length(), &numWritten);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
RefPtr<DataPipeReceiver> reader2;
IPC::MessageReader msgReader(msg);
@ -365,7 +366,7 @@ TEST(DataPipe, SerializeReader)
ASSERT_TRUE(reader2);
rv = reader2->Available(&available);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(available, 512u);
ConsumeAndValidateStream(reader2, inputData);
}

3
netwerk/test/gtest/TestBase64Stream.cpp
View file

@ -5,6 +5,7 @@
#include "gtest/gtest.h"
#include "mozilla/Base64.h"
#include "mozilla/gtest/MozAssertions.h"
#include "nsIInputStream.h"
namespace mozilla {
@ -85,7 +86,7 @@ TEST(TestBase64Stream, Run)
nsAutoString encodedData;
nsresult rv = Base64EncodeInputStream(ts, encodedData, input.Length());
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
EXPECT_TRUE(encodedData.EqualsLiteral("SGVsbG8gV29ybGQh"));
}

15
netwerk/test/gtest/TestBind.cpp
View file

@ -4,6 +4,7 @@
#include "TestCommon.h"
#include "gtest/gtest.h"
#include "mozilla/gtest/MozAssertions.h"
#include "nsISocketTransportService.h"
#include "nsISocketTransport.h"
#include "nsIServerSocket.h"
@ -105,18 +106,18 @@ TEST(TestBind, MainTest)
ASSERT_TRUE(server);
nsresult rv = server->Init(-1, true, -1);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
int32_t serverPort;
rv = server->GetPort(&serverPort);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
RefPtr<WaitForCondition> waiter = new WaitForCondition();
// Listening.
RefPtr<ServerListener> serverListener = new ServerListener(waiter);
rv = server->AsyncListen(serverListener);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
//
// Client side
@ -124,7 +125,7 @@ TEST(TestBind, MainTest)
uint32_t bindingPort = 20000;
nsCOMPtr<nsISocketTransportService> service =
do_GetService("@mozilla.org/network/socket-transport-service;1", &rv);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIInputStream> inputStream;
RefPtr<ClientInputCallback> clientCallback;
@ -140,7 +141,7 @@ TEST(TestBind, MainTest)
rv = service->CreateTransport(nsTArray<nsCString>(),
"127.0.0.1"_ns, serverPort, nullptr,
nullptr, getter_AddRefs(client));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Bind to a port. It's possible that we are binding to a port
// that is currently in use. If we failed to bind, we try next
@ -150,14 +151,14 @@ TEST(TestBind, MainTest)
bindingAddr.inet.ip = 0;
bindingAddr.inet.port = PR_htons(bindingPort);
rv = client->Bind(&bindingAddr);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Open IO streams, to make client SocketTransport connect to
// server.
clientCallback = new ClientInputCallback(waiter);
rv = client->OpenInputStream(nsITransport::OPEN_UNBUFFERED, 0, 0,
getter_AddRefs(inputStream));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIAsyncInputStream> asyncInputStream =
do_QueryInterface(inputStream);

43
netwerk/test/gtest/TestCookie.cpp
View file

@ -20,6 +20,7 @@
#include "nsIPrefBranch.h"
#include "nsIPrefService.h"
#include "mozilla/dom/Document.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/Preferences.h"
#include "mozilla/Unused.h"
#include "mozilla/net/CookieJarSettings.h"
@ -77,7 +78,7 @@ void SetACookieInternal(nsICookieService* aCookieService, const char* aSpec,
nsresult rv0;
nsCOMPtr<nsIScriptSecurityManager> ssm =
do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID, &rv0);
ASSERT_TRUE(NS_SUCCEEDED(rv0));
ASSERT_NS_SUCCEEDED(rv0);
nsCOMPtr<nsIPrincipal> specPrincipal;
nsCString tmpString(aSpec);
ssm->CreateContentPrincipalFromOrigin(tmpString,
@ -101,7 +102,7 @@ void SetACookieInternal(nsICookieService* aCookieService, const char* aSpec,
nsresult rv = aCookieService->SetCookieStringFromHttp(
uri, nsDependentCString(aCookieString), dummyChannel);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
}
void SetACookieJarBlocked(nsICookieService* aCookieService, const char* aSpec,
@ -214,10 +215,10 @@ TEST(TestCookie, TestCookieMain)
nsCOMPtr<nsICookieService> cookieService =
do_GetService(kCookieServiceCID, &rv0);
ASSERT_TRUE(NS_SUCCEEDED(rv0));
ASSERT_NS_SUCCEEDED(rv0);
nsCOMPtr<nsIPrefBranch> prefBranch = do_GetService(kPrefServiceCID, &rv0);
ASSERT_TRUE(NS_SUCCEEDED(rv0));
ASSERT_NS_SUCCEEDED(rv0);
InitPrefs(prefBranch);
@ -746,7 +747,7 @@ TEST(TestCookie, TestCookieMain)
// *** nsICookieManager interface tests
nsCOMPtr<nsICookieManager> cookieMgr =
do_GetService(NS_COOKIEMANAGER_CONTRACTID, &rv0);
ASSERT_TRUE(NS_SUCCEEDED(rv0));
ASSERT_NS_SUCCEEDED(rv0);
const nsCOMPtr<nsICookieManager>& cookieMgr2 = cookieMgr;
ASSERT_TRUE(cookieMgr2);
@ -754,7 +755,7 @@ TEST(TestCookie, TestCookieMain)
mozilla::OriginAttributes attrs;
// first, ensure a clean slate
EXPECT_TRUE(NS_SUCCEEDED(cookieMgr->RemoveAll()));
EXPECT_NS_SUCCEEDED(cookieMgr->RemoveAll());
// add some cookies
EXPECT_TRUE(NS_SUCCEEDED(cookieMgr2->AddNative("cookiemgr.test"_ns, // domain
"/foo"_ns, // path
@ -791,7 +792,7 @@ TEST(TestCookie, TestCookieMain)
nsICookie::SCHEME_HTTPS)));
// confirm using enumerator
nsTArray<RefPtr<nsICookie>> cookies;
EXPECT_TRUE(NS_SUCCEEDED(cookieMgr->GetCookies(cookies)));
EXPECT_NS_SUCCEEDED(cookieMgr->GetCookies(cookies));
nsCOMPtr<nsICookie> expiredCookie, newDomainCookie;
for (const auto& cookie : cookies) {
nsAutoCString name;
@ -830,7 +831,7 @@ TEST(TestCookie, TestCookieMain)
"cookiemgr.test"_ns, "/foo"_ns, "test2"_ns, &attrs, &found)));
EXPECT_TRUE(found);
// double-check RemoveAll() using the enumerator
EXPECT_TRUE(NS_SUCCEEDED(cookieMgr->RemoveAll()));
EXPECT_NS_SUCCEEDED(cookieMgr->RemoveAll());
cookies.SetLength(0);
EXPECT_TRUE(NS_SUCCEEDED(cookieMgr->GetCookies(cookies)) &&
cookies.IsEmpty());
@ -880,7 +881,7 @@ TEST(TestCookie, TestCookieMain)
// *** SameSite attribute - parsing and cookie storage tests
// Clear the cookies
EXPECT_TRUE(NS_SUCCEEDED(cookieMgr->RemoveAll()));
EXPECT_NS_SUCCEEDED(cookieMgr->RemoveAll());
// None of these cookies will be set because using
// CookieJarSettings::GetBlockingAll().
@ -897,7 +898,7 @@ TEST(TestCookie, TestCookieMain)
"lax=yes; samesite=lax");
cookies.SetLength(0);
EXPECT_TRUE(NS_SUCCEEDED(cookieMgr->GetCookies(cookies)));
EXPECT_NS_SUCCEEDED(cookieMgr->GetCookies(cookies));
EXPECT_TRUE(cookies.IsEmpty());
@ -919,7 +920,7 @@ TEST(TestCookie, TestCookieMain)
SetACookie(cookieService, "http://samesite.test", "lax=yes; samesite=lax");
cookies.SetLength(0);
EXPECT_TRUE(NS_SUCCEEDED(cookieMgr->GetCookies(cookies)));
EXPECT_NS_SUCCEEDED(cookieMgr->GetCookies(cookies));
// check the cookies for the required samesite value
for (const auto& cookie : cookies) {
@ -946,7 +947,7 @@ TEST(TestCookie, TestCookieMain)
// *** SameSite attribute
// Clear the cookies
EXPECT_TRUE(NS_SUCCEEDED(cookieMgr->RemoveAll()));
EXPECT_NS_SUCCEEDED(cookieMgr->RemoveAll());
// please note that the flag aForeign is always set to true using this test
// setup because no nsIChannel is passed to SetCookieString(). therefore we
@ -992,18 +993,18 @@ TEST(TestCookie, SameSiteLax)
nsCOMPtr<nsICookieService> cookieService =
do_GetService(kCookieServiceCID, &rv);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsICookieManager> cookieMgr =
do_GetService(NS_COOKIEMANAGER_CONTRACTID, &rv);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
EXPECT_TRUE(NS_SUCCEEDED(cookieMgr->RemoveAll()));
EXPECT_NS_SUCCEEDED(cookieMgr->RemoveAll());
SetACookie(cookieService, "http://samesite.test", "unset=yes");
nsTArray<RefPtr<nsICookie>> cookies;
EXPECT_TRUE(NS_SUCCEEDED(cookieMgr->GetCookies(cookies)));
EXPECT_NS_SUCCEEDED(cookieMgr->GetCookies(cookies));
EXPECT_EQ(cookies.Length(), (uint64_t)1);
Cookie* cookie = static_cast<Cookie*>(cookies[0].get());
@ -1013,16 +1014,16 @@ TEST(TestCookie, SameSiteLax)
Preferences::SetCString("network.cookie.sameSite.laxByDefault.disabledHosts",
"foo.com,samesite.test,bar.net");
EXPECT_TRUE(NS_SUCCEEDED(cookieMgr->RemoveAll()));
EXPECT_NS_SUCCEEDED(cookieMgr->RemoveAll());
cookies.SetLength(0);
EXPECT_TRUE(NS_SUCCEEDED(cookieMgr->GetCookies(cookies)));
EXPECT_NS_SUCCEEDED(cookieMgr->GetCookies(cookies));
EXPECT_EQ(cookies.Length(), (uint64_t)0);
SetACookie(cookieService, "http://samesite.test", "unset=yes");
cookies.SetLength(0);
EXPECT_TRUE(NS_SUCCEEDED(cookieMgr->GetCookies(cookies)));
EXPECT_NS_SUCCEEDED(cookieMgr->GetCookies(cookies));
EXPECT_EQ(cookies.Length(), (uint64_t)1);
cookie = static_cast<Cookie*>(cookies[0].get());
@ -1040,7 +1041,7 @@ TEST(TestCookie, OnionSite)
nsCOMPtr<nsICookieService> cookieService =
do_GetService(kCookieServiceCID, &rv);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// .onion secure cookie tests
SetACookie(cookieService, "http://123456789abcdef.onion/",
@ -1068,7 +1069,7 @@ TEST(TestCookie, HiddenPrefix)
nsCOMPtr<nsICookieService> cookieService =
do_GetService(kCookieServiceCID, &rv);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
SetACookie(cookieService, "http://hiddenprefix.test/", "=__Host-test=a");
GetACookie(cookieService, "http://hiddenprefix.test/", cookie);

3
netwerk/test/gtest/TestLinkHeader.cpp
View file

@ -5,6 +5,7 @@
#include "gtest/gtest-param-test.h"
#include "gtest/gtest.h"
#include "mozilla/gtest/MozAssertions.h"
#include "nsNetUtil.h"
using namespace mozilla::net;
@ -293,7 +294,7 @@ TEST_P(AnchorTest, Anchor) {
LinkHeader linkHeader = LinkHeaderFromHrefAndAnchor(test.href, test.anchor);
nsCOMPtr<nsIURI> baseURI;
ASSERT_TRUE(NS_SUCCEEDED(NS_NewURI(getter_AddRefs(baseURI), test.baseURI)));
ASSERT_NS_SUCCEEDED(NS_NewURI(getter_AddRefs(baseURI), test.baseURI));
nsCOMPtr<nsIURI> resolved;
ASSERT_TRUE(NS_SUCCEEDED(

11
netwerk/test/gtest/TestNamedPipeService.cpp
View file

@ -9,6 +9,7 @@
#include <windows.h>
#include "mozilla/Atomics.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/Monitor.h"
#include "nsNamedPipeService.h"
#include "nsNetCID.h"
@ -258,15 +259,15 @@ TEST(TestNamedPipeService, Test)
HANDLE readPipe, writePipe;
nsresult rv = CreateNamedPipe(&readPipe, &writePipe);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
RefPtr<nsNamedPipeDataObserver> readObserver =
new nsNamedPipeDataObserver(readPipe);
RefPtr<nsNamedPipeDataObserver> writeObserver =
new nsNamedPipeDataObserver(writePipe);
ASSERT_TRUE(NS_SUCCEEDED(svc->AddDataObserver(readPipe, readObserver)));
ASSERT_TRUE(NS_SUCCEEDED(svc->AddDataObserver(writePipe, writeObserver)));
ASSERT_NS_SUCCEEDED(svc->AddDataObserver(readPipe, readObserver));
ASSERT_NS_SUCCEEDED(svc->AddDataObserver(writePipe, writeObserver));
ASSERT_EQ(std::size_t(writeObserver->Write(TEST_STR, sizeof(TEST_STR))),
sizeof(TEST_STR));
@ -275,6 +276,6 @@ TEST(TestNamedPipeService, Test)
sizeof(TEST_STR));
ASSERT_STREQ(buffer, TEST_STR) << "I/O mismatch";
ASSERT_TRUE(NS_SUCCEEDED(svc->RemoveDataObserver(readPipe, readObserver)));
ASSERT_TRUE(NS_SUCCEEDED(svc->RemoveDataObserver(writePipe, writeObserver)));
ASSERT_NS_SUCCEEDED(svc->RemoveDataObserver(readPipe, readObserver));
ASSERT_NS_SUCCEEDED(svc->RemoveDataObserver(writePipe, writeObserver));
}

37
netwerk/test/gtest/TestUDPSocket.cpp
View file

@ -10,6 +10,7 @@
#include "nsINetAddr.h"
#include "nsITimer.h"
#include "nsContentUtils.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/net/DNS.h"
#include "prerror.h"
#include "nsComponentManagerUtils.h"
@ -242,10 +243,10 @@ TEST(TestUDPSocket, TestUDPSocketMain)
// Create UDPSocket
nsCOMPtr<nsIUDPSocket> server, client;
server = do_CreateInstance("@mozilla.org/network/udp-socket;1", &rv);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
client = do_CreateInstance("@mozilla.org/network/udp-socket;1", &rv);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
RefPtr<WaitForCondition> waiter = new WaitForCondition();
@ -256,7 +257,7 @@ TEST(TestUDPSocket, TestUDPSocketMain)
// Bind server socket to 0.0.0.0
rv = server->Init(0, false, systemPrincipal, true, 0);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
int32_t serverPort;
server->GetPort(&serverPort);
server->AsyncListen(serverListener);
@ -274,34 +275,34 @@ TEST(TestUDPSocket, TestUDPSocketMain)
phase = TEST_OUTPUT_STREAM;
rv = client->Send("127.0.0.1"_ns, serverPort, data, &count);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
EXPECT_EQ(count, sizeof(uint32_t));
// Wait for server
waiter->Wait(1);
ASSERT_TRUE(NS_SUCCEEDED(serverListener->mResult));
ASSERT_NS_SUCCEEDED(serverListener->mResult);
// Read response from server
ASSERT_TRUE(NS_SUCCEEDED(clientListener->mResult));
ASSERT_NS_SUCCEEDED(clientListener->mResult);
mozilla::net::NetAddr clientAddr;
rv = client->GetAddress(&clientAddr);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// The client address is 0.0.0.0, but Windows won't receive packets there, so
// use 127.0.0.1 explicitly
clientAddr.inet.ip = PR_htonl(127 << 24 | 1);
phase = TEST_SEND_API;
rv = server->SendWithAddress(&clientAddr, data, &count);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
EXPECT_EQ(count, sizeof(uint32_t));
// Wait for server
waiter->Wait(1);
ASSERT_TRUE(NS_SUCCEEDED(serverListener->mResult));
ASSERT_NS_SUCCEEDED(serverListener->mResult);
// Read response from server
ASSERT_TRUE(NS_SUCCEEDED(clientListener->mResult));
ASSERT_NS_SUCCEEDED(clientListener->mResult);
// Setup timer to detect multicast failure
nsCOMPtr<nsITimer> timer = NS_NewTimer();
@ -316,19 +317,19 @@ TEST(TestUDPSocket, TestUDPSocketMain)
multicastAddr.inet.ip = PR_htonl(224 << 24 | 255);
multicastAddr.inet.port = PR_htons(serverPort);
rv = server->JoinMulticastAddr(multicastAddr, nullptr);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Send multicast ping
timerCb->mResult = NS_OK;
timer->InitWithCallback(timerCb, MULTICAST_TIMEOUT, nsITimer::TYPE_ONE_SHOT);
rv = client->SendWithAddress(&multicastAddr, data, &count);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
EXPECT_EQ(count, sizeof(uint32_t));
// Wait for server to receive successfully
waiter->Wait(1);
ASSERT_TRUE(NS_SUCCEEDED(serverListener->mResult));
ASSERT_TRUE(NS_SUCCEEDED(timerCb->mResult));
ASSERT_NS_SUCCEEDED(serverListener->mResult);
ASSERT_NS_SUCCEEDED(timerCb->mResult);
timer->Cancel();
// Disable multicast loopback
@ -340,7 +341,7 @@ TEST(TestUDPSocket, TestUDPSocketMain)
timerCb->mResult = NS_OK;
timer->InitWithCallback(timerCb, MULTICAST_TIMEOUT, nsITimer::TYPE_ONE_SHOT);
rv = client->SendWithAddress(&multicastAddr, data, &count);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
EXPECT_EQ(count, sizeof(uint32_t));
// Wait for server to fail to receive
@ -362,7 +363,7 @@ TEST(TestUDPSocket, TestUDPSocketMain)
timerCb->mResult = NS_OK;
timer->InitWithCallback(timerCb, MULTICAST_TIMEOUT, nsITimer::TYPE_ONE_SHOT);
rv = client->SendWithAddress(&multicastAddr, data, &count);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
EXPECT_EQ(count, sizeof(uint32_t));
// Wait for server to fail to receive
@ -378,13 +379,13 @@ TEST(TestUDPSocket, TestUDPSocketMain)
// Leave multicast group
rv = server->LeaveMulticastAddr(multicastAddr, nullptr);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Send multicast ping
timerCb->mResult = NS_OK;
timer->InitWithCallback(timerCb, MULTICAST_TIMEOUT, nsITimer::TYPE_ONE_SHOT);
rv = client->SendWithAddress(&multicastAddr, data, &count);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
EXPECT_EQ(count, sizeof(uint32_t));
// Wait for server to fail to receive

7
security/manager/ssl/tests/gtest/HMACTest.cpp
View file

@ -2,6 +2,7 @@
#include "gtest/gtest.h"
#include "ScopedNSSTypes.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/Span.h"
#include "nss.h"
#include "secoidt.h"
@ -46,13 +47,13 @@ TEST_P(psm_HMAC, Test) {
const HMACTestCase& testCase(GetParam());
nsresult rv = hmac.Begin(testCase.hashAlg,
mozilla::Span(kTestKey, sizeof(kTestKey) - 1));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = hmac.Update(reinterpret_cast<const unsigned char*>(kTestInput),
sizeof(kTestInput) - 1);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsTArray<uint8_t> output;
rv = hmac.End(output);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
EXPECT_EQ(output.Length(), testCase.expectedOutput.length());
for (size_t i = 0; i < output.Length(); i++) {
EXPECT_EQ(output[i], testCase.expectedOutput[i]);

29
startupcache/test/TestStartupCache.cpp
View file

@ -19,6 +19,7 @@
#include "prenv.h"
#include "prio.h"
#include "prprf.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/Maybe.h"
#include "mozilla/Printf.h"
#include "mozilla/UniquePtr.h"
@ -83,18 +84,18 @@ TEST_F(TestStartupCache, StartupWriteRead) {
uint32_t len;
rv = sc->PutBuffer(id, UniquePtr<char[]>(strdup(buf)), strlen(buf) + 1);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
rv = sc->GetBuffer(id, &outbuf, &len);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
EXPECT_STREQ(buf, outbuf);
rv = sc->ResetStartupWriteTimer();
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
WaitForStartupTimer();
rv = sc->GetBuffer(id, &outbuf, &len);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
EXPECT_STREQ(buf, outbuf);
}
@ -108,7 +109,7 @@ TEST_F(TestStartupCache, WriteInvalidateRead) {
ASSERT_TRUE(sc);
rv = sc->PutBuffer(id, UniquePtr<char[]>(strdup(buf)), strlen(buf) + 1);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
sc->InvalidateCache();
@ -123,7 +124,7 @@ TEST_F(TestStartupCache, WriteObject) {
constexpr auto spec = "http://www.mozilla.org"_ns;
rv = NS_MutateURI(NS_SIMPLEURIMUTATOR_CONTRACTID).SetSpec(spec).Finalize(obj);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
StartupCache* sc = StartupCache::GetSingleton();
@ -137,7 +138,7 @@ TEST_F(TestStartupCache, WriteObject) {
ASSERT_TRUE(storageStream);
rv = storageStream->Init(256, (uint32_t)-1);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIObjectOutputStream> objectOutput =
do_CreateInstance("@mozilla.org/binaryoutputstream;1");
@ -146,11 +147,11 @@ TEST_F(TestStartupCache, WriteObject) {
nsCOMPtr<nsIOutputStream> outputStream = do_QueryInterface(storageStream);
rv = objectOutput->SetOutputStream(outputStream);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
nsCOMPtr<nsISupports> objQI(do_QueryInterface(obj));
rv = objectOutput->WriteObject(objQI, true);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
UniquePtr<char[]> buf;
uint32_t len;
@ -159,26 +160,26 @@ TEST_F(TestStartupCache, WriteObject) {
// Since this is a post-startup write, it should be written and
// available.
rv = sc->PutBuffer(id, std::move(buf), len);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
const char* buf2;
uint32_t len2;
nsCOMPtr<nsIObjectInputStream> objectInput;
rv = sc->GetBuffer(id, &buf2, &len2);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
rv = NewObjectInputStreamFromBuffer(buf2, len2, getter_AddRefs(objectInput));
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
nsCOMPtr<nsISupports> deserialized;
rv = objectInput->ReadObject(true, getter_AddRefs(deserialized));
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIURI> uri(do_QueryInterface(deserialized));
ASSERT_TRUE(uri);
nsCString outSpec;
rv = uri->GetSpec(outSpec);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
ASSERT_TRUE(outSpec.Equals(spec));
}

5
toolkit/components/antitracking/test/gtest/TestStoragePrincipalHelper.cpp
View file

@ -15,6 +15,7 @@
#include "nsNetUtil.h"
#include "nsStringFwd.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/NullPrincipal.h"
#include "mozilla/Preferences.h"
#include "mozilla/RefPtr.h"
@ -105,13 +106,13 @@ TEST(TestStoragePrincipalHelper, TestCreateNullPrincipal)
nsCOMPtr<nsIPrincipal> storagePrincipal;
rv = StoragePrincipalHelper::Create(mockChannel, nullPrincipal, true,
getter_AddRefs(storagePrincipal));
EXPECT_TRUE(NS_FAILED(rv)) << "Should fail for NullPrincipal";
EXPECT_NS_FAILED(rv) << "Should fail for NullPrincipal";
EXPECT_FALSE(storagePrincipal);
nsCOMPtr<nsIPrincipal> storagePrincipalSW;
rv = StoragePrincipalHelper::CreatePartitionedPrincipalForServiceWorker(
nullPrincipal, cookieJarSettings, getter_AddRefs(storagePrincipalSW));
EXPECT_TRUE(NS_FAILED(rv)) << "Should fail for NullPrincipal";
EXPECT_NS_FAILED(rv) << "Should fail for NullPrincipal";
EXPECT_FALSE(storagePrincipal);
}

5
toolkit/components/telemetry/geckoview/gtest/TestGeckoViewStreaming.cpp
View file

@ -5,6 +5,7 @@
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/Preferences.h"
#include "mozilla/Services.h"
#include "mozilla/Telemetry.h"
@ -164,9 +165,9 @@ TEST_F(TelemetryStreamingFixture, MultipleThreads) {
"accumulate 14", [&]() { Telemetry::Accumulate(kTestHgram, kSample2); });
nsresult rv = NS_NewNamedThread("t1", getter_AddRefs(t1), r1);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
rv = NS_NewNamedThread("t2", getter_AddRefs(t2), r2);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
// Give the threads a chance to do their work.
PR_Sleep(PR_MillisecondsToInterval(1));

3
toolkit/components/telemetry/tests/gtest/TelemetryTestHelpers.cpp
View file

@ -11,6 +11,7 @@
#include "js/CallAndConstruct.h" // JS_CallFunctionName
#include "js/PropertyAndElement.h" // JS_Enumerate, JS_GetElement, JS_GetProperty
#include "mozilla/CycleCollectedJSContext.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/Unused.h"
#include "nsTArray.h"
#include "nsPrintfCString.h"
@ -295,7 +296,7 @@ void GetEncodedOriginStrings(
rv = TelemetryOrigin::GetEncodedOriginSnapshot(false /* clear */, aCx,
&snapshot);
ASSERT_FALSE(NS_FAILED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_FALSE(snapshot.isNullOrUndefined())
<< "Encoded snapshot must not be null/undefined.";

1
toolkit/components/url-classifier/tests/gtest/Common.h
View file

@ -11,6 +11,7 @@
#include "nsTArray.h"
#include "gtest/gtest.h"
#include "mozilla/gtest/MozAssertions.h"
using namespace mozilla::safebrowsing;

8
toolkit/components/url-classifier/tests/gtest/TestFindFullHash.cpp
View file

@ -45,13 +45,13 @@ TEST(UrlClassifierFindFullHash, Request)
nsresult rv;
rv = urlUtil->MakeFindFullHashRequestV4(listNames, listStateArray,
prefixArray, requestBase64);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Base64 URL decode first.
FallibleTArray<uint8_t> requestBinary;
rv = Base64URLDecode(requestBase64, Base64URLDecodePaddingPolicy::Require,
requestBinary);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Parse the FindFullHash binary and compare with the expected values.
FindFullHashesRequest r;
@ -72,7 +72,7 @@ TEST(UrlClassifierFindFullHash, Request)
uint32_t expectedThreatType;
rv =
urlUtil->ConvertListNameToThreatType(listNames[i], &expectedThreatType);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(threatInfo.threat_types(i), (int)expectedThreatType);
}
@ -156,7 +156,7 @@ class MyParseCallback final : public nsIUrlClassifierParseFindFullHashCallback {
nsCString tableNames;
nsresult rv =
urlUtil->ConvertThreatTypeToListNames(expected.mThreatType, tableNames);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(aTableNames.Equals(tableNames));
VerifyDuration(aPerHashCacheDuration, expected.mPerHashCacheDuration);

2
toolkit/components/url-classifier/tests/gtest/TestUrlClassifierTableUpdateV4.cpp
View file

@ -169,7 +169,7 @@ static void Clear() {
static void testUpdateFail(TableUpdateArray& tableUpdates) {
nsresult rv = SyncApplyUpdates(tableUpdates);
ASSERT_TRUE(NS_FAILED(rv));
ASSERT_NS_FAILED(rv);
}
static void testUpdate(TableUpdateArray& tableUpdates,

10
toolkit/components/url-classifier/tests/gtest/TestVariableLengthPrefixSet.cpp
View file

@ -156,13 +156,13 @@ class UrlClassifierPrefixSetTest : public ::testing::TestWithParam<uint32_t> {
mArray = aArray.Clone();
PrefixArrayToPrefixStringMap(mArray, mMap);
ASSERT_TRUE(NS_SUCCEEDED(mCache->Build(mMap)));
ASSERT_NS_SUCCEEDED(mCache->Build(mMap));
Verify();
}
void SetupPrefixesAndVerify(_PrefixArray&& aArray) {
nsresult rv = SetupPrefixes(std::move(aArray));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
Verify();
}
@ -171,7 +171,7 @@ class UrlClassifierPrefixSetTest : public ::testing::TestWithParam<uint32_t> {
RandomPrefixes(N, MIN, MAX, mArray);
PrefixArrayToPrefixStringMap(mArray, mMap);
ASSERT_TRUE(NS_SUCCEEDED(mCache->Build(mMap)));
ASSERT_NS_SUCCEEDED(mCache->Build(mMap));
Verify();
}
@ -317,11 +317,11 @@ TEST_P(UrlClassifierPrefixSetTest, MinMaxPrefixSet) {
// Prefix size less than 4-bytes should fail
nsresult rv = SetupPrefixes({_Prefix("123")});
ASSERT_TRUE(NS_FAILED(rv));
ASSERT_NS_FAILED(rv);
// Prefix size greater than 32-bytes should fail
rv = SetupPrefixes({_Prefix("1aaa2bbb3ccc4ddd5eee6fff7ggg8hhh9")});
ASSERT_TRUE(NS_FAILED(rv));
ASSERT_NS_FAILED(rv);
}
// Test save then load prefix set with only 4-bytes prefixes

5
toolkit/xre/dllservices/tests/gtest/TestDLLBlocklist.cpp
View file

@ -13,6 +13,7 @@
#include "mozilla/ArrayUtils.h"
#include "mozilla/Char16.h"
#include "mozilla/gtest/MozAssertions.h"
#include "nsDirectoryServiceDefs.h"
#include "nsDirectoryServiceUtils.h"
#include "nsString.h"
@ -25,13 +26,13 @@ static nsString GetFullPath(const nsAString& aLeaf) {
EXPECT_TRUE(NS_SUCCEEDED(
NS_GetSpecialDirectory(NS_OS_CURRENT_WORKING_DIR, getter_AddRefs(f))));
EXPECT_TRUE(NS_SUCCEEDED(f->Append(aLeaf)));
EXPECT_NS_SUCCEEDED(f->Append(aLeaf));
bool exists;
EXPECT_TRUE(NS_SUCCEEDED(f->Exists(&exists)) && exists);
nsString ret;
EXPECT_TRUE(NS_SUCCEEDED(f->GetPath(ret)));
EXPECT_NS_SUCCEEDED(f->GetPath(ret));
return ret;
}

11
toolkit/xre/dllservices/tests/gtest/TestUntrustedModules.cpp
View file

@ -7,6 +7,7 @@
#include "js/RegExp.h"
#include "mozilla/BinarySearch.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/SpinEventLoopUntil.h"
#include "mozilla/UntrustedModulesProcessor.h"
#include "mozilla/WinDllServices.h"
@ -164,11 +165,11 @@ class UntrustedModulesFixture : public TelemetryTestFixture {
nsCOMPtr<nsIFile> file;
EXPECT_TRUE(NS_SUCCEEDED(NS_GetSpecialDirectory(NS_OS_CURRENT_WORKING_DIR,
getter_AddRefs(file))));
EXPECT_TRUE(NS_SUCCEEDED(file->Append(aLeaf)));
EXPECT_NS_SUCCEEDED(file->Append(aLeaf));
bool exists;
EXPECT_TRUE(NS_SUCCEEDED(file->Exists(&exists)) && exists);
nsString fullPath;
EXPECT_TRUE(NS_SUCCEEDED(file->GetPath(fullPath)));
EXPECT_NS_SUCCEEDED(file->GetPath(fullPath));
return fullPath;
}
@ -208,7 +209,7 @@ class UntrustedModulesFixture : public TelemetryTestFixture {
UntrustedModulesCollector collector;
ModuleLoadCounter waitForOne({kTestModules[0]}, {1});
EXPECT_TRUE(NS_SUCCEEDED(collector.Collect(waitForOne)));
EXPECT_NS_SUCCEEDED(collector.Collect(waitForOne));
EXPECT_TRUE(waitForOne.Remains({kTestModules[0]}, {0}));
EXPECT_EQ(collector.Data().length(), 1U);
@ -428,8 +429,8 @@ TEST_F(UntrustedModulesFixture, Serialize) {
ValidateJSValue(kPattern, ArrayLength(kPattern) - 1,
[&backup1, &backup2](
Telemetry::UntrustedModulesDataSerializer& aSerializer) {
EXPECT_TRUE(NS_SUCCEEDED(aSerializer.Add(backup1)));
EXPECT_TRUE(NS_SUCCEEDED(aSerializer.Add(backup2)));
EXPECT_NS_SUCCEEDED(aSerializer.Add(backup1));
EXPECT_NS_SUCCEEDED(aSerializer.Add(backup2));
});
}

17
toolkit/xre/test/gtest/TestAssembleCommandLineWin.cpp
View file

@ -7,6 +7,7 @@
#include "mozilla/AssembleCmdLine.h"
#include "mozilla/CmdLineAndEnvUtils.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/UniquePtrExtensions.h"
#include "WinRemoteMessage.h"
@ -134,7 +135,7 @@ TEST(WinRemoteMessage, SendReceive)
nsCOMPtr<nsIFile> workingDir;
receiver.Parse(v0.CopyData());
EXPECT_TRUE(NS_SUCCEEDED(receiver.CommandLineRunner()->GetLength(&len)));
EXPECT_NS_SUCCEEDED(receiver.CommandLineRunner()->GetLength(&len));
EXPECT_EQ(static_cast<size_t>(len), ArrayLength(kExpectedArgsW));
for (size_t i = 0; i < ArrayLength(kExpectedArgsW); ++i) {
EXPECT_TRUE(
@ -146,7 +147,7 @@ TEST(WinRemoteMessage, SendReceive)
NS_ERROR_NOT_INITIALIZED);
receiver.Parse(v1.CopyData());
EXPECT_TRUE(NS_SUCCEEDED(receiver.CommandLineRunner()->GetLength(&len)));
EXPECT_NS_SUCCEEDED(receiver.CommandLineRunner()->GetLength(&len));
EXPECT_EQ(static_cast<size_t>(len), ArrayLength(kExpectedArgsW));
for (size_t i = 0; i < ArrayLength(kExpectedArgsW); ++i) {
EXPECT_TRUE(
@ -155,11 +156,11 @@ TEST(WinRemoteMessage, SendReceive)
}
EXPECT_TRUE(NS_SUCCEEDED(receiver.CommandLineRunner()->GetWorkingDirectory(
getter_AddRefs(workingDir))));
EXPECT_TRUE(NS_SUCCEEDED(workingDir->GetPath(arg)));
EXPECT_NS_SUCCEEDED(workingDir->GetPath(arg));
EXPECT_STREQ(arg.get(), workingDirW);
receiver.Parse(v2.CopyData());
EXPECT_TRUE(NS_SUCCEEDED(receiver.CommandLineRunner()->GetLength(&len)));
EXPECT_NS_SUCCEEDED(receiver.CommandLineRunner()->GetLength(&len));
EXPECT_EQ(static_cast<size_t>(len), ArrayLength(kExpectedArgsW));
for (size_t i = 0; i < ArrayLength(kExpectedArgsW); ++i) {
EXPECT_TRUE(
@ -168,7 +169,7 @@ TEST(WinRemoteMessage, SendReceive)
}
EXPECT_TRUE(NS_SUCCEEDED(receiver.CommandLineRunner()->GetWorkingDirectory(
getter_AddRefs(workingDir))));
EXPECT_TRUE(NS_SUCCEEDED(workingDir->GetPath(arg)));
EXPECT_NS_SUCCEEDED(workingDir->GetPath(arg));
EXPECT_STREQ(arg.get(), workingDirW);
}
@ -199,21 +200,21 @@ TEST(WinRemoteMessage, NonNullTerminatedBuffer)
copyData.dwData =
static_cast<ULONG_PTR>(WinRemoteMessageVersion::CommandLineOnly);
EXPECT_TRUE(NS_SUCCEEDED(receiver.Parse(&copyData)));
EXPECT_NS_SUCCEEDED(receiver.Parse(&copyData));
EXPECT_EQ(receiver.CommandLineRunner()->GetWorkingDirectory(
getter_AddRefs(workingDir)),
NS_ERROR_NOT_INITIALIZED);
copyData.dwData = static_cast<ULONG_PTR>(
WinRemoteMessageVersion::CommandLineAndWorkingDir);
EXPECT_TRUE(NS_SUCCEEDED(receiver.Parse(&copyData)));
EXPECT_NS_SUCCEEDED(receiver.Parse(&copyData));
EXPECT_EQ(receiver.CommandLineRunner()->GetWorkingDirectory(
getter_AddRefs(workingDir)),
NS_ERROR_NOT_INITIALIZED);
copyData.dwData = static_cast<ULONG_PTR>(
WinRemoteMessageVersion::CommandLineAndWorkingDirInUtf16);
EXPECT_TRUE(NS_SUCCEEDED(receiver.Parse(&copyData)));
EXPECT_NS_SUCCEEDED(receiver.Parse(&copyData));
EXPECT_EQ(receiver.CommandLineRunner()->GetWorkingDirectory(
getter_AddRefs(workingDir)),
NS_ERROR_NOT_INITIALIZED);

7
tools/profiler/tests/gtest/GeckoProfiler.cpp
View file

@ -22,6 +22,7 @@
#include "prthread.h"
#include "gtest/gtest.h"
#include "mozilla/gtest/MozAssertions.h"
#include <thread>
@ -1908,7 +1909,7 @@ TEST(GeckoProfiler, DifferentThreads)
nsCOMPtr<nsIThread> thread;
nsresult rv = NS_NewNamedThread("GeckoProfGTest", getter_AddRefs(thread));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Control the profiler on a background thread and verify flags on the
// main thread.
@ -3803,7 +3804,7 @@ TEST(GeckoProfiler, StreamJSONForThisProcessThreaded)
// Same as the previous test, but calling some things on background threads.
nsCOMPtr<nsIThread> thread;
nsresult rv = NS_NewNamedThread("GeckoProfGTest", getter_AddRefs(thread));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
uint32_t features = ProfilerFeature::StackWalk;
const char* filters[] = {"GeckoMain"};
@ -3970,7 +3971,7 @@ TEST(GeckoProfiler, SuspendAndSample)
{
nsCOMPtr<nsIThread> thread;
nsresult rv = NS_NewNamedThread("GeckoProfGTest", getter_AddRefs(thread));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ProfilerThreadId tid = profiler_current_thread_id();

191
uriloader/preload/gtest/TestFetchPreloader.cpp
View file

@ -4,6 +4,7 @@
#include "mozilla/dom/XMLDocument.h"
#include "mozilla/dom/ReferrerPolicyBinding.h"
#include "mozilla/FetchPreloader.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/Maybe.h"
#include "mozilla/PreloadHashKey.h"
#include "mozilla/SpinEventLoopUntil.h"
@ -288,14 +289,14 @@ TEST(TestFetchPreloader, CacheNoneBeforeConsume)
mozilla::dom::ReferrerPolicy::_empty, doc)));
RefPtr<FakeListener> listener = new FakeListener();
EXPECT_TRUE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Start()));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("one"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("two"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("three"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Stop(NS_OK)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
EXPECT_TRUE(listener->mOnStart);
@ -325,21 +326,21 @@ TEST(TestFetchPreloader, CacheStartBeforeConsume)
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Start()));
EXPECT_NS_SUCCEEDED(channel->Start());
RefPtr<FakeListener> listener = new FakeListener();
EXPECT_TRUE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
EXPECT_TRUE(listener->mOnStart);
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("one"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("two"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("three"_ns)));
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
EXPECT_TRUE(listener->mOnData.EqualsLiteral("onetwothree"));
EXPECT_TRUE(NS_SUCCEEDED(channel->Stop(NS_OK)));
EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
EXPECT_TRUE(listener->mOnStop && *listener->mOnStop == NS_OK);
Yield();
@ -365,21 +366,21 @@ TEST(TestFetchPreloader, CachePartOfDataBeforeConsume)
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Start()));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("one"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("two"_ns)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
RefPtr<FakeListener> listener = new FakeListener();
EXPECT_TRUE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
EXPECT_TRUE(listener->mOnStart);
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("three"_ns)));
EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
EXPECT_TRUE(listener->mOnData.EqualsLiteral("onetwothree"));
EXPECT_TRUE(NS_SUCCEEDED(channel->Stop(NS_OK)));
EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
EXPECT_TRUE(listener->mOnStop && *listener->mOnStop == NS_OK);
Yield();
@ -405,21 +406,21 @@ TEST(TestFetchPreloader, CacheAllDataBeforeConsume)
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Start()));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("one"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("two"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("three"_ns)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
// Request consumation of the preload...
RefPtr<FakeListener> listener = new FakeListener();
EXPECT_TRUE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
EXPECT_TRUE(listener->mOnStart);
EXPECT_TRUE(listener->mOnData.EqualsLiteral("onetwothree"));
EXPECT_TRUE(NS_SUCCEEDED(channel->Stop(NS_OK)));
EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
EXPECT_TRUE(listener->mOnStop && *listener->mOnStop == NS_OK);
Yield();
@ -445,14 +446,14 @@ TEST(TestFetchPreloader, CacheAllBeforeConsume)
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Start()));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("one"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("two"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("three"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Stop(NS_OK)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
RefPtr<FakeListener> listener = new FakeListener();
EXPECT_TRUE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
@ -484,14 +485,14 @@ TEST(TestFetchPreloader, CacheAllBeforeConsumeWithChannelError)
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Start()));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("one"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("two"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("three"_ns)));
EXPECT_TRUE(NS_FAILED(channel->Stop(ERROR_ONSTOP)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
EXPECT_NS_FAILED(channel->Stop(ERROR_ONSTOP));
RefPtr<FakeListener> listener = new FakeListener();
EXPECT_TRUE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
@ -523,14 +524,14 @@ TEST(TestFetchPreloader, CacheAllBeforeConsumeWithChannelCancel)
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Start()));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("one"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("two"_ns)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
channel->Cancel(ERROR_CANCEL);
EXPECT_TRUE(NS_FAILED(channel->Stop(ERROR_CANCEL)));
EXPECT_NS_FAILED(channel->Stop(ERROR_CANCEL));
RefPtr<FakeListener> listener = new FakeListener();
EXPECT_TRUE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
@ -566,16 +567,16 @@ TEST(TestFetchPreloader, CacheAllBeforeConsumeThrowFromOnStartRequest)
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Start()));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("one"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("two"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("three"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Stop(NS_OK)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
RefPtr<FakeListener> listener = new FakeListener();
listener->mOnStartResult = ERROR_THROW;
EXPECT_TRUE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
@ -606,16 +607,16 @@ TEST(TestFetchPreloader, CacheAllBeforeConsumeThrowFromOnDataAvailable)
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Start()));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("one"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("two"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("three"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Stop(NS_OK)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
RefPtr<FakeListener> listener = new FakeListener();
listener->mOnDataResult = ERROR_THROW;
EXPECT_TRUE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
@ -646,16 +647,16 @@ TEST(TestFetchPreloader, CacheAllBeforeConsumeThrowFromOnStopRequest)
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Start()));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("one"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("two"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("three"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Stop(NS_OK)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
RefPtr<FakeListener> listener = new FakeListener();
listener->mOnStopResult = ERROR_THROW;
EXPECT_TRUE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
@ -688,11 +689,11 @@ TEST(TestFetchPreloader, CacheAllBeforeConsumeCancelInOnStartRequest)
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Start()));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("one"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("two"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("three"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Stop(NS_OK)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
RefPtr<FakeListener> listener = new FakeListener();
listener->mCancelIn = FakeListener::OnStart;
@ -700,7 +701,7 @@ TEST(TestFetchPreloader, CacheAllBeforeConsumeCancelInOnStartRequest)
// status.
listener->mOnStartResult = ERROR_THROW;
EXPECT_TRUE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
@ -731,11 +732,11 @@ TEST(TestFetchPreloader, CacheAllBeforeConsumeCancelInOnDataAvailable)
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Start()));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("one"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("two"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("three"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Stop(NS_OK)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
RefPtr<FakeListener> listener = new FakeListener();
listener->mCancelIn = FakeListener::OnData;
@ -743,7 +744,7 @@ TEST(TestFetchPreloader, CacheAllBeforeConsumeCancelInOnDataAvailable)
// status.
listener->mOnDataResult = ERROR_THROW;
EXPECT_TRUE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
@ -775,19 +776,19 @@ TEST(TestFetchPreloader, CachePartlyBeforeConsumeCancelInOnDataAvailable)
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Start()));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("one"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("two"_ns)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
RefPtr<FakeListener> listener = new FakeListener();
listener->mCancelIn = FakeListener::OnData;
EXPECT_TRUE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
EXPECT_TRUE(NS_FAILED(channel->Data("three"_ns)));
EXPECT_TRUE(NS_FAILED(channel->Stop(NS_OK)));
EXPECT_NS_FAILED(channel->Data("three"_ns));
EXPECT_NS_FAILED(channel->Stop(NS_OK));
EXPECT_TRUE(listener->mOnStart);
EXPECT_TRUE(listener->mOnData.EqualsLiteral("one"));
@ -816,22 +817,22 @@ TEST(TestFetchPreloader, CachePartlyBeforeConsumeCancelInOnStartRequestAndRace)
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Start()));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("one"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("two"_ns)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
// This has to simulate a possibiilty when stream listener notifications from
// the channel are already pending in the queue while AsyncConsume is called.
// At this moment the listener has not been notified yet.
NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("three"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Stop(NS_OK)));
EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
}));
RefPtr<FakeListener> listener = new FakeListener();
listener->mCancelIn = FakeListener::OnStart;
EXPECT_TRUE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
// Check listener's been fed properly. Expected is to NOT get any data and
@ -865,22 +866,22 @@ TEST(TestFetchPreloader, CachePartlyBeforeConsumeCancelInOnDataAvailableAndRace)
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Start()));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("one"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("two"_ns)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
// This has to simulate a possibiilty when stream listener notifications from
// the channel are already pending in the queue while AsyncConsume is called.
// At this moment the listener has not been notified yet.
NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("three"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Stop(NS_OK)));
EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
}));
RefPtr<FakeListener> listener = new FakeListener();
listener->mCancelIn = FakeListener::OnData;
EXPECT_TRUE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
// Check listener's been fed properly. Expected is to NOT get anything after
@ -914,22 +915,22 @@ TEST(TestFetchPreloader, CachePartlyBeforeConsumeThrowFromOnStartRequestAndRace)
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Start()));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("one"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("two"_ns)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
// This has to simulate a possibiilty when stream listener notifications from
// the channel are already pending in the queue while AsyncConsume is called.
// At this moment the listener has not been notified yet.
NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
EXPECT_TRUE(NS_SUCCEEDED(channel->Data("three"_ns)));
EXPECT_TRUE(NS_SUCCEEDED(channel->Stop(NS_OK)));
EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
}));
RefPtr<FakeListener> listener = new FakeListener();
listener->mOnStartResult = ERROR_THROW;
EXPECT_TRUE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
// Check listener's been fed properly. Expected is to NOT get any data and

5
xpcom/tests/gtest/Helpers.cpp
View file

@ -10,6 +10,7 @@
#include <algorithm>
#include "gtest/gtest.h"
#include "mozilla/gtest/MozAssertions.h"
#include "nsIOutputStream.h"
#include "nsStreamUtils.h"
#include "nsTArray.h"
@ -51,7 +52,7 @@ void Write(nsIOutputStream* aStream, const nsTArray<char>& aData,
uint32_t numWritten;
nsresult rv =
aStream->Write(aData.Elements() + aOffset, remaining, &numWritten);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
if (numWritten < 1) {
break;
}
@ -80,7 +81,7 @@ void ConsumeAndValidateStream(nsIInputStream* aStream,
const nsACString& aExpectedData) {
nsAutoCString outputData;
nsresult rv = NS_ConsumeStream(aStream, UINT32_MAX, outputData);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(aExpectedData.Length(), outputData.Length());
ASSERT_TRUE(aExpectedData.Equals(outputData));
}

3
xpcom/tests/gtest/TestAtoms.cpp
View file

@ -13,6 +13,7 @@
#include "nsThreadUtils.h"
#include "gtest/gtest.h"
#include "mozilla/gtest/MozAssertions.h"
using namespace mozilla;
@ -166,7 +167,7 @@ TEST(Atoms, ConcurrentAccessing)
for (size_t i = 0; i < kThreadCount; i++) {
nsresult rv = NS_NewNamedThread("Atom Test", getter_AddRefs(threads[i]),
new nsAtomRunner);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
}
for (size_t i = 0; i < kThreadCount; i++) {
threads[i]->Shutdown();

3
xpcom/tests/gtest/TestAutoRefCnt.cpp
View file

@ -11,6 +11,7 @@
#include "nsThreadUtils.h"
#include "gtest/gtest.h"
#include "mozilla/gtest/MozAssertions.h"
using namespace mozilla;
@ -54,7 +55,7 @@ TEST(AutoRefCnt, ThreadSafeAutoRefCntBalance)
nsresult rv =
NS_NewNamedThread("AutoRefCnt Test", getter_AddRefs(threads[i]),
new nsThreadSafeAutoRefCntRunner);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
}
for (size_t i = 0; i < kThreadCount; i++) {
threads[i]->Shutdown();

3
xpcom/tests/gtest/TestAvailableMemoryWatcherMac.cpp
View file

@ -7,6 +7,7 @@
#include "gtest/gtest.h"
#include "AvailableMemoryWatcher.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/SpinEventLoopUntil.h"
#include "mozilla/Unused.h"
#include "nsIObserver.h"
@ -180,7 +181,7 @@ class MemoryWatcherTelemetryEvent {
// The third token should be a valid floating number.
nsresult rv;
tokens[2].ToDouble(&rv);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
}
};

3
xpcom/tests/gtest/TestAvailableMemoryWatcherWin.cpp
View file

@ -11,6 +11,7 @@
#include "AvailableMemoryWatcher.h"
#include "mozilla/Atomics.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/Preferences.h"
#include "mozilla/SpinEventLoopUntil.h"
#include "mozilla/Unused.h"
@ -495,7 +496,7 @@ class MemoryWatcherTelemetryEvent {
// The third token should be a valid floating number.
nsresult rv;
tokens[2].ToDouble(&rv);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
}
};

39
xpcom/tests/gtest/TestBase64.cpp
View file

@ -11,6 +11,7 @@
#include "nsString.h"
#include "gtest/gtest.h"
#include "mozilla/gtest/MozAssertions.h"
struct Chunk {
Chunk(uint32_t l, const char* c) : mLength(l), mData(c) {}
@ -198,12 +199,12 @@ TEST(Base64, StreamEncoder)
nsresult rv;
rv = encoder->EncodeToString(stream, 0, wideString);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
stream->Reset();
rv = encoder->EncodeToCString(stream, 0, string);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
stream->CheckTest(wideString);
stream->CheckTest(string);
@ -231,7 +232,7 @@ TEST(Base64, RFC4648Encoding)
nsDependentCString in(testcase.mInput);
nsAutoCString out;
nsresult rv = mozilla::Base64Encode(in, out);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(out.EqualsASCII(testcase.mOutput));
}
@ -239,7 +240,7 @@ TEST(Base64, RFC4648Encoding)
NS_ConvertUTF8toUTF16 in(testcase.mInput);
nsAutoString out;
nsresult rv = mozilla::Base64Encode(in, out);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(out.EqualsASCII(testcase.mOutput));
}
}
@ -251,7 +252,7 @@ TEST(Base64, RFC4648Encoding_TransformAndAppend_EmptyPrefix)
nsAutoString out;
nsresult rv =
mozilla::Base64EncodeAppend(in.BeginReading(), in.Length(), out);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(out.EqualsASCII(testcase.mOutput));
}
}
@ -263,7 +264,7 @@ TEST(Base64, RFC4648Encoding_TransformAndAppend_NonEmptyPrefix)
nsAutoString out{u"foo"_ns};
nsresult rv =
mozilla::Base64EncodeAppend(in.BeginReading(), in.Length(), out);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(StringBeginsWith(out, u"foo"_ns));
ASSERT_TRUE(Substring(out, 3).EqualsASCII(testcase.mOutput));
}
@ -275,7 +276,7 @@ TEST(Base64, RFC4648Decoding)
nsDependentCString out(testcase.mOutput);
nsAutoCString in;
nsresult rv = mozilla::Base64Decode(out, in);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(in.EqualsASCII(testcase.mInput));
}
@ -283,7 +284,7 @@ TEST(Base64, RFC4648Decoding)
NS_ConvertUTF8toUTF16 out(testcase.mOutput);
nsAutoString in;
nsresult rv = mozilla::Base64Decode(out, in);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(in.EqualsASCII(testcase.mInput));
}
}
@ -300,7 +301,7 @@ TEST(Base64, RFC4648DecodingRawPointers)
uint32_t binaryLength = 0;
nsresult rv = mozilla::Base64Decode(testcase.mOutput, outputLength, &buffer,
&binaryLength);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(binaryLength, inputLength);
ASSERT_STREQ(testcase.mInput, buffer);
free(buffer);
@ -325,7 +326,7 @@ TEST(Base64, NonASCIIEncoding)
nsDependentCString in(testcase.mInput);
nsAutoCString out;
nsresult rv = mozilla::Base64Encode(in, out);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(out.EqualsASCII(testcase.mOutput));
}
}
@ -337,7 +338,7 @@ TEST(Base64, NonASCIIEncodingWideString)
// XXX Handles Latin1 despite the name
AppendASCIItoUTF16(nsDependentCString(testcase.mInput), in);
nsresult rv = mozilla::Base64Encode(in, out);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(out.EqualsASCII(testcase.mOutput));
}
}
@ -348,7 +349,7 @@ TEST(Base64, NonASCIIDecoding)
nsDependentCString out(testcase.mOutput);
nsAutoCString in;
nsresult rv = mozilla::Base64Decode(out, in);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(in.Equals(testcase.mInput));
}
}
@ -360,7 +361,7 @@ TEST(Base64, NonASCIIDecodingWideString)
// XXX Handles Latin1 despite the name
AppendASCIItoUTF16(nsDependentCString(testcase.mOutput), out);
nsresult rv = mozilla::Base64Decode(out, in);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Can't use EqualsASCII, because our comparison string isn't ASCII.
for (size_t i = 0; i < in.Length(); ++i) {
ASSERT_TRUE(((unsigned int)in[i] & 0xff00) == 0);
@ -378,14 +379,14 @@ TEST(Base64, EncodeNon8BitWideString)
const nsAutoString non8Bit(u"\x1ff");
nsAutoString out;
nsresult rv = mozilla::Base64Encode(non8Bit, out);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(out.EqualsLiteral("/w=="));
}
{
const nsAutoString non8Bit(u"\xfff");
nsAutoString out;
nsresult rv = mozilla::Base64Encode(non8Bit, out);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(out.EqualsLiteral("/w=="));
}
}
@ -401,7 +402,7 @@ TEST(Base64, DecodeNon8BitWideString)
ASSERT_EQ(non8Bit.Length(), 4u);
nsAutoString out;
nsresult rv = mozilla::Base64Decode(non8Bit, out);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(out.Equals(expectedOutput));
}
{
@ -409,7 +410,7 @@ TEST(Base64, DecodeNon8BitWideString)
const nsAutoString expectedOutput(u"\xff");
nsAutoString out;
nsresult rv = mozilla::Base64Decode(non8Bit, out);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(out.Equals(expectedOutput));
}
}
@ -432,7 +433,7 @@ TEST(Base64, TruncateOnInvalidDecodeCString)
constexpr auto invalid = "@@=="_ns;
nsAutoCString out("I should be truncated!");
nsresult rv = mozilla::Base64Decode(invalid, out);
ASSERT_TRUE(NS_FAILED(rv));
ASSERT_NS_FAILED(rv);
ASSERT_EQ(out.Length(), 0u);
}
@ -441,7 +442,7 @@ TEST(Base64, TruncateOnInvalidDecodeWideString)
constexpr auto invalid = u"@@=="_ns;
nsAutoString out(u"I should be truncated!");
nsresult rv = mozilla::Base64Decode(invalid, out);
ASSERT_TRUE(NS_FAILED(rv));
ASSERT_NS_FAILED(rv);
ASSERT_EQ(out.Length(), 0u);
}

9
xpcom/tests/gtest/TestCOMPtr.cpp
View file

@ -6,6 +6,7 @@
#include "nsCOMPtr.h"
#include "gtest/gtest.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/Unused.h"
#define NS_IFOO_IID \
@ -187,12 +188,12 @@ TEST(COMPtr, Bloat_Raw_Unsafe)
// ER: I'm not sure what this is testing...
IBar* barP = 0;
nsresult rv = CreateIBar(reinterpret_cast<void**>(&barP));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(barP);
IFoo* fooP = 0;
rv = barP->QueryInterface(NS_GET_IID(IFoo), reinterpret_cast<void**>(&fooP));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(fooP);
NS_RELEASE(fooP);
@ -204,11 +205,11 @@ TEST(COMPtr, Bloat_Smart)
// ER: I'm not sure what this is testing...
nsCOMPtr<IBar> barP;
nsresult rv = CreateIBar(getter_AddRefs(barP));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(barP);
nsCOMPtr<IFoo> fooP(do_QueryInterface(static_cast<nsISupports*>(barP), &rv));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(fooP);
}

41
xpcom/tests/gtest/TestCloneInputStream.cpp
View file

@ -6,6 +6,7 @@
#include "gtest/gtest.h"
#include "Helpers.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/Unused.h"
#include "nsICloneableInputStream.h"
#include "nsIMultiplexInputStream.h"
@ -18,7 +19,7 @@ TEST(CloneInputStream, InvalidInput)
{
nsCOMPtr<nsIInputStream> clone;
nsresult rv = NS_CloneInputStream(nullptr, getter_AddRefs(clone));
ASSERT_TRUE(NS_FAILED(rv));
ASSERT_NS_FAILED(rv);
ASSERT_FALSE(clone);
}
@ -30,11 +31,11 @@ TEST(CloneInputStream, CloneableInput)
nsCOMPtr<nsIInputStream> stream;
nsresult rv = NS_NewCStringInputStream(getter_AddRefs(stream), inputString);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIInputStream> clone;
rv = NS_CloneInputStream(stream, getter_AddRefs(clone));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
testing::ConsumeAndValidateStream(stream, inputString);
testing::ConsumeAndValidateStream(clone, inputString);
@ -86,7 +87,7 @@ TEST(CloneInputStream, NonCloneableInput_NoFallback)
nsCOMPtr<nsIInputStream> base;
nsresult rv = NS_NewCStringInputStream(getter_AddRefs(base), inputString);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIInputStream> stream = new NonCloneableInputStream(base.forget());
@ -95,7 +96,7 @@ TEST(CloneInputStream, NonCloneableInput_NoFallback)
nsCOMPtr<nsIInputStream> clone;
rv = NS_CloneInputStream(stream, getter_AddRefs(clone));
ASSERT_TRUE(NS_FAILED(rv));
ASSERT_NS_FAILED(rv);
ASSERT_TRUE(clone == nullptr);
testing::ConsumeAndValidateStream(stream, inputString);
@ -109,7 +110,7 @@ TEST(CloneInputStream, NonCloneableInput_Fallback)
nsCOMPtr<nsIInputStream> base;
nsresult rv = NS_NewCStringInputStream(getter_AddRefs(base), inputString);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIInputStream> stream = new NonCloneableInputStream(base.forget());
@ -120,7 +121,7 @@ TEST(CloneInputStream, NonCloneableInput_Fallback)
nsCOMPtr<nsIInputStream> replacement;
rv = NS_CloneInputStream(stream, getter_AddRefs(clone),
getter_AddRefs(replacement));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(clone != nullptr);
ASSERT_TRUE(replacement != nullptr);
ASSERT_TRUE(stream.get() != replacement.get());
@ -135,7 +136,7 @@ TEST(CloneInputStream, NonCloneableInput_Fallback)
do {
mozilla::Unused << PR_Sleep(PR_INTERVAL_NO_WAIT);
rv = stream->Available(&available);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
} while (available < inputString.Length());
testing::ConsumeAndValidateStream(stream, inputString);
@ -157,10 +158,10 @@ TEST(CloneInputStream, CloneMultiplexStream)
nsCOMPtr<nsIInputStream> base;
nsresult rv = NS_NewCStringInputStream(getter_AddRefs(base), inputString);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = multiplexStream->AppendStream(base);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
}
// Unread stream should clone successfully.
@ -170,18 +171,18 @@ TEST(CloneInputStream, CloneMultiplexStream)
nsCOMPtr<nsIInputStream> clone;
nsresult rv = NS_CloneInputStream(stream, getter_AddRefs(clone));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
testing::ConsumeAndValidateStream(clone, doubled);
// Stream that has been read should fail.
char buffer[512];
uint32_t read;
rv = stream->Read(buffer, 512, &read);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIInputStream> clone2;
rv = NS_CloneInputStream(stream, getter_AddRefs(clone2));
ASSERT_TRUE(NS_FAILED(rv));
ASSERT_NS_FAILED(rv);
}
TEST(CloneInputStream, CloneMultiplexStreamPartial)
@ -199,34 +200,34 @@ TEST(CloneInputStream, CloneMultiplexStreamPartial)
nsCOMPtr<nsIInputStream> base;
nsresult rv = NS_NewCStringInputStream(getter_AddRefs(base), inputString);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = multiplexStream->AppendStream(base);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
}
// Fail when first stream read, but second hasn't been started.
char buffer[1024];
uint32_t read;
nsresult rv = stream->Read(buffer, 1024, &read);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIInputStream> clone;
rv = NS_CloneInputStream(stream, getter_AddRefs(clone));
ASSERT_TRUE(NS_FAILED(rv));
ASSERT_NS_FAILED(rv);
// Fail after beginning read of second stream.
rv = stream->Read(buffer, 512, &read);
ASSERT_TRUE(NS_SUCCEEDED(rv) && read == 512);
rv = NS_CloneInputStream(stream, getter_AddRefs(clone));
ASSERT_TRUE(NS_FAILED(rv));
ASSERT_NS_FAILED(rv);
// Fail at the end.
nsAutoCString consumed;
rv = NS_ConsumeStream(stream, UINT32_MAX, consumed);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = NS_CloneInputStream(stream, getter_AddRefs(clone));
ASSERT_TRUE(NS_FAILED(rv));
ASSERT_NS_FAILED(rv);
}

3
xpcom/tests/gtest/TestDelayedRunnable.cpp
View file

@ -10,6 +10,7 @@
#include "mozilla/TaskQueue.h"
#include "gtest/gtest.h"
#include "mozilla/gtest/MozAssertions.h"
#include "MediaTimer.h"
#include "mozilla/media/MediaUtils.h"
#include "VideoUtils.h"
@ -91,7 +92,7 @@ TEST(DelayedRunnable, BackgroundTaskQueueShutdownTask)
nsCOMPtr<nsISerialEventTarget> taskQueue;
nsresult rv = NS_CreateBackgroundTaskQueue("TestDelayedRunnable",
getter_AddRefs(taskQueue));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Leak the queue, so it gets cleaned up by xpcom-shutdown.
nsISerialEventTarget* tq = taskQueue.forget().take();

4
xpcom/tests/gtest/TestFile.cpp
View file

@ -17,6 +17,7 @@
#include "nsPrintfCString.h"
#include "gtest/gtest.h"
#include "mozilla/gtest/MozAssertions.h"
#ifdef XP_WIN
bool gTestWithPrefix_Win = false;
@ -79,8 +80,7 @@ static bool TestInvalidFileName(nsIFile* aBase, const char* aName) {
nsCString name = FixName(aName);
nsresult rv = file->AppendNative(name);
if (NS_SUCCEEDED(rv)) {
EXPECT_FALSE(NS_SUCCEEDED(rv))
<< "AppendNative with invalid filename " << name.get();
EXPECT_NS_FAILED(rv) << "AppendNative with invalid filename " << name.get();
return false;
}

7
xpcom/tests/gtest/TestFileNTFSSpecialPaths.cpp
View file

@ -6,6 +6,7 @@
#include "prio.h"
#include "prsystem.h"
#include "mozilla/gtest/MozAssertions.h"
#include "nsComponentManagerUtils.h"
#include "nsIFile.h"
#include "nsILocalFileWin.h"
@ -282,7 +283,7 @@ TEST(TestFileNTFSSpecialPaths, Normalization)
// nsIFile::Normalize, because normalization doesn't happen reliably,
// and where it does happen consumers often don't check for errors.
nsresult rv = file->InitWithPath(startingFilePath);
EXPECT_TRUE(NS_FAILED(rv))
<< " from normalizing '" << NS_ConvertUTF16toUTF8(startingFilePath).get()
<< "' rv=" << std::hex << (unsigned int)rv;
EXPECT_NS_FAILED(rv) << " from normalizing '"
<< NS_ConvertUTF16toUTF8(startingFilePath).get()
<< "' rv=" << std::hex << (unsigned int)rv;
}

179
xpcom/tests/gtest/TestMultiplexInputStream.cpp
View file

@ -5,6 +5,7 @@
* 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"
@ -35,11 +36,11 @@ TEST(MultiplexInputStream, Seek_SET)
nsCOMPtr<nsIInputStream> inputStream2;
nsCOMPtr<nsIInputStream> inputStream3;
nsresult rv = NS_NewCStringInputStream(getter_AddRefs(inputStream1), buf1);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = NS_NewCStringInputStream(getter_AddRefs(inputStream2), buf2);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = NS_NewCStringInputStream(getter_AddRefs(inputStream3), buf3);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIMultiplexInputStream> multiplexStream =
do_CreateInstance("@mozilla.org/io/multiplex-input-stream;1");
@ -48,11 +49,11 @@ TEST(MultiplexInputStream, Seek_SET)
ASSERT_TRUE(stream);
rv = multiplexStream->AppendStream(inputStream1);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = multiplexStream->AppendStream(inputStream2);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = multiplexStream->AppendStream(inputStream3);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
int64_t tell;
uint64_t length;
@ -63,71 +64,71 @@ TEST(MultiplexInputStream, Seek_SET)
// Seek forward in first input stream
rv = seekStream->Seek(nsISeekableStream::NS_SEEK_SET, 1);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = stream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ((uint64_t)buf1.Length() + buf2.Length() + buf3.Length() - 1,
length);
rv = seekStream->Tell(&tell);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(tell, 1);
// Check read is correct
rv = stream->Read(readBuf, 3, &count);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ((uint64_t)3, count);
rv = stream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ((uint64_t)buf1.Length() + buf2.Length() + buf3.Length() - 4,
length);
ASSERT_EQ(0, strncmp(readBuf, "ell", count));
rv = seekStream->Tell(&tell);
ASSERT_TRUE(NS_SUCCEEDED(rv));
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_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = stream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ((uint64_t)buf3.Length(), length);
rv = seekStream->Tell(&tell);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(tell, int64_t(buf1.Length() + buf2.Length()));
// Check read is correct
rv = stream->Read(readBuf, 5, &count);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ((uint64_t)5, count);
rv = stream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
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_TRUE(NS_SUCCEEDED(rv));
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_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = stream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ((uint64_t)buf2.Length() + buf3.Length(), length);
rv = seekStream->Tell(&tell);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(tell, int64_t(buf1.Length()));
// Check read is correct
rv = stream->Read(readBuf, 6, &count);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ((uint64_t)6, count);
rv = stream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
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_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(tell, int64_t(buf1.Length() + 6));
}
@ -144,11 +145,11 @@ TEST(MultiplexInputStream, Seek_CUR)
nsCOMPtr<nsIInputStream> inputStream2;
nsCOMPtr<nsIInputStream> inputStream3;
nsresult rv = NS_NewCStringInputStream(getter_AddRefs(inputStream1), buf1);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = NS_NewCStringInputStream(getter_AddRefs(inputStream2), buf2);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = NS_NewCStringInputStream(getter_AddRefs(inputStream3), buf3);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIMultiplexInputStream> multiplexStream =
do_CreateInstance("@mozilla.org/io/multiplex-input-stream;1");
@ -157,11 +158,11 @@ TEST(MultiplexInputStream, Seek_CUR)
ASSERT_TRUE(stream);
rv = multiplexStream->AppendStream(inputStream1);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = multiplexStream->AppendStream(inputStream2);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = multiplexStream->AppendStream(inputStream3);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
int64_t tell;
uint64_t length;
@ -172,54 +173,54 @@ TEST(MultiplexInputStream, Seek_CUR)
// Seek forward in first input stream
rv = seekStream->Seek(nsISeekableStream::NS_SEEK_CUR, 1);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = stream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ((uint64_t)buf1.Length() + buf2.Length() + buf3.Length() - 1,
length);
rv = seekStream->Tell(&tell);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(tell, 1);
// Check read is correct
rv = stream->Read(readBuf, 3, &count);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ((uint64_t)3, count);
rv = stream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ((uint64_t)buf1.Length() + buf2.Length() + buf3.Length() - 4,
length);
ASSERT_EQ(0, strncmp(readBuf, "ell", count));
rv = seekStream->Tell(&tell);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(tell, 4);
// Let's go to the second stream
rv = seekStream->Seek(nsISeekableStream::NS_SEEK_CUR, 11);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = seekStream->Tell(&tell);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(tell, 15);
rv = stream->Read(readBuf, 3, &count);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ((uint64_t)3, count);
ASSERT_EQ(0, strncmp(readBuf, "qui", count));
rv = seekStream->Tell(&tell);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(tell, 18);
// Let's go back to the first stream
rv = seekStream->Seek(nsISeekableStream::NS_SEEK_CUR, -9);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = seekStream->Tell(&tell);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(tell, 9);
rv = stream->Read(readBuf, 3, &count);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ((uint64_t)3, count);
ASSERT_EQ(0, strncmp(readBuf, "ldT", count));
rv = seekStream->Tell(&tell);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(tell, 12);
}
@ -236,11 +237,11 @@ TEST(MultiplexInputStream, Seek_END)
nsCOMPtr<nsIInputStream> inputStream2;
nsCOMPtr<nsIInputStream> inputStream3;
nsresult rv = NS_NewCStringInputStream(getter_AddRefs(inputStream1), buf1);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = NS_NewCStringInputStream(getter_AddRefs(inputStream2), buf2);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = NS_NewCStringInputStream(getter_AddRefs(inputStream3), buf3);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIMultiplexInputStream> multiplexStream =
do_CreateInstance("@mozilla.org/io/multiplex-input-stream;1");
@ -249,11 +250,11 @@ TEST(MultiplexInputStream, Seek_END)
ASSERT_TRUE(stream);
rv = multiplexStream->AppendStream(inputStream1);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = multiplexStream->AppendStream(inputStream2);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = multiplexStream->AppendStream(inputStream3);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
int64_t tell;
uint64_t length;
@ -262,26 +263,26 @@ TEST(MultiplexInputStream, Seek_END)
// SEEK_END wants <=0 values
rv = seekStream->Seek(nsISeekableStream::NS_SEEK_END, 1);
ASSERT_TRUE(NS_FAILED(rv));
ASSERT_NS_FAILED(rv);
// Let's go to the end.
rv = seekStream->Seek(nsISeekableStream::NS_SEEK_END, 0);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = stream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ((uint64_t)0, length);
rv = seekStream->Tell(&tell);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(tell, int64_t(buf1.Length() + buf2.Length() + buf3.Length()));
// -1
rv = seekStream->Seek(nsISeekableStream::NS_SEEK_END, -1);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = stream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ((uint64_t)1, length);
rv = seekStream->Tell(&tell);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(tell, int64_t(buf1.Length() + buf2.Length() + buf3.Length() - 1));
// Almost at the beginning
@ -290,12 +291,12 @@ TEST(MultiplexInputStream, Seek_END)
tell -= buf2.Length();
tell -= buf3.Length();
rv = seekStream->Seek(nsISeekableStream::NS_SEEK_END, tell);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = stream->Available(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(length, buf1.Length() + buf2.Length() + buf3.Length() - 1);
rv = seekStream->Tell(&tell);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(tell, 1);
}
@ -645,17 +646,17 @@ TEST(MultiplexInputStream, Bufferable)
buf1.AssignLiteral("Hello ");
nsCOMPtr<nsIInputStream> inputStream1;
nsresult rv = NS_NewCStringInputStream(getter_AddRefs(inputStream1), buf1);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCString buf2;
buf2.AssignLiteral("world");
nsCOMPtr<nsIInputStream> inputStream2 = new NonBufferableStringStream(buf2);
rv = multiplexStream->AppendStream(inputStream1);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = multiplexStream->AppendStream(inputStream2);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIInputStream> stream(do_QueryInterface(multiplexStream));
ASSERT_TRUE(!!stream);
@ -663,7 +664,7 @@ TEST(MultiplexInputStream, Bufferable)
char buf3[1024];
uint32_t size = 0;
rv = stream->ReadSegments(NS_CopySegmentToBuffer, buf3, sizeof(buf3), &size);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(size, buf1.Length() + buf2.Length());
ASSERT_TRUE(!strncmp(buf3, "Hello world", size));
@ -682,10 +683,10 @@ TEST(MultiplexInputStream, QILengthInputStream)
{
nsCOMPtr<nsIInputStream> inputStream;
nsresult rv = NS_NewCStringInputStream(getter_AddRefs(inputStream), buf);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = multiplexStream->AppendStream(inputStream);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIInputStreamLength> fsis = do_QueryInterface(multiplexStream);
ASSERT_TRUE(!fsis);
@ -702,7 +703,7 @@ TEST(MultiplexInputStream, QILengthInputStream)
new testing::LengthInputStream(buf, true, false);
nsresult rv = multiplexStream->AppendStream(inputStream);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIInputStreamLength> fsis = do_QueryInterface(multiplexStream);
ASSERT_TRUE(!!fsis);
@ -719,7 +720,7 @@ TEST(MultiplexInputStream, QILengthInputStream)
new testing::LengthInputStream(buf, true, true);
nsresult rv = multiplexStream->AppendStream(inputStream);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIInputStreamLength> fsis = do_QueryInterface(multiplexStream);
ASSERT_TRUE(!!fsis);
@ -741,17 +742,17 @@ TEST(MultiplexInputStream, LengthInputStream)
nsCOMPtr<nsIInputStream> inputStream;
nsresult rv = NS_NewCStringInputStream(getter_AddRefs(inputStream), buf);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = multiplexStream->AppendStream(inputStream);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// A LengthInputStream, non-async.
RefPtr<testing::LengthInputStream> lengthStream =
new testing::LengthInputStream(buf, true, false);
rv = multiplexStream->AppendStream(lengthStream);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIInputStreamLength> fsis = do_QueryInterface(multiplexStream);
ASSERT_TRUE(!!fsis);
@ -759,7 +760,7 @@ TEST(MultiplexInputStream, LengthInputStream)
// Size is the sum of the 2 streams.
int64_t length;
rv = fsis->Length(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(int64_t(buf.Length() * 2), length);
// An async LengthInputStream.
@ -768,7 +769,7 @@ TEST(MultiplexInputStream, LengthInputStream)
NS_BASE_STREAM_WOULD_BLOCK);
rv = multiplexStream->AppendStream(asyncLengthStream);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIAsyncInputStreamLength> afsis =
do_QueryInterface(multiplexStream);
@ -792,10 +793,10 @@ TEST(MultiplexInputStream, LengthInputStream)
lengthStream = new testing::LengthInputStream(buf, true, false, NS_OK, true);
rv = multiplexStream->AppendStream(lengthStream);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = fsis->Length(&length);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(-1, length);
// Another async LengthInputStream.
@ -803,7 +804,7 @@ TEST(MultiplexInputStream, LengthInputStream)
buf, true, true, NS_BASE_STREAM_WOULD_BLOCK);
rv = multiplexStream->AppendStream(asyncLengthStream);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
afsis = do_QueryInterface(multiplexStream);
ASSERT_TRUE(!!afsis);
@ -835,36 +836,36 @@ void TestMultiplexStreamReadWhileWaiting(nsIAsyncInputStream* pipeIn,
nsCOMPtr<nsIMultiplexInputStream> multiplexStream =
do_CreateInstance("@mozilla.org/io/multiplex-input-stream;1");
ASSERT_TRUE(NS_SUCCEEDED(multiplexStream->AppendStream(pipeIn)));
ASSERT_NS_SUCCEEDED(multiplexStream->AppendStream(pipeIn));
nsCOMPtr<nsIInputStream> stringStream;
ASSERT_TRUE(NS_SUCCEEDED(
NS_NewCStringInputStream(getter_AddRefs(stringStream), "xxxx\0"_ns)));
ASSERT_TRUE(NS_SUCCEEDED(multiplexStream->AppendStream(stringStream)));
ASSERT_NS_SUCCEEDED(multiplexStream->AppendStream(stringStream));
nsCOMPtr<nsIAsyncInputStream> asyncMultiplex =
do_QueryInterface(multiplexStream);
ASSERT_TRUE(asyncMultiplex);
RefPtr<testing::InputStreamCallback> cb = new testing::InputStreamCallback();
ASSERT_TRUE(NS_SUCCEEDED(asyncMultiplex->AsyncWait(cb, 0, 0, mainThread)));
ASSERT_NS_SUCCEEDED(asyncMultiplex->AsyncWait(cb, 0, 0, mainThread));
EXPECT_FALSE(cb->Called());
NS_ProcessPendingEvents(mainThread);
EXPECT_FALSE(cb->Called());
uint64_t available;
ASSERT_TRUE(NS_SUCCEEDED(asyncMultiplex->Available(&available)));
ASSERT_NS_SUCCEEDED(asyncMultiplex->Available(&available));
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_TRUE(NS_SUCCEEDED(pipeOut->Write(toWrite, sizeof(toWrite), &written)));
ASSERT_NS_SUCCEEDED(pipeOut->Write(toWrite, sizeof(toWrite), &written));
EXPECT_EQ(written, sizeof(toWrite));
EXPECT_FALSE(cb->Called());
ASSERT_TRUE(NS_SUCCEEDED(asyncMultiplex->Available(&available)));
ASSERT_NS_SUCCEEDED(asyncMultiplex->Available(&available));
EXPECT_EQ(available, sizeof(toWrite));
// Read that data from the stream
@ -875,14 +876,14 @@ void TestMultiplexStreamReadWhileWaiting(nsIAsyncInputStream* pipeIn,
EXPECT_EQ(read, sizeof(toRead));
EXPECT_STREQ(toRead, toWrite);
EXPECT_FALSE(cb->Called());
ASSERT_TRUE(NS_SUCCEEDED(asyncMultiplex->Available(&available)));
ASSERT_NS_SUCCEEDED(asyncMultiplex->Available(&available));
EXPECT_EQ(available, 0u);
// The multiplex stream will have detected the read and prevented the callback
// from having been called yet.
NS_ProcessPendingEvents(mainThread);
EXPECT_FALSE(cb->Called());
ASSERT_TRUE(NS_SUCCEEDED(asyncMultiplex->Available(&available)));
ASSERT_NS_SUCCEEDED(asyncMultiplex->Available(&available));
EXPECT_EQ(available, 0u);
// Write more data and close, then make sure we can read everything else in
@ -892,11 +893,11 @@ void TestMultiplexStreamReadWhileWaiting(nsIAsyncInputStream* pipeIn,
NS_SUCCEEDED(pipeOut->Write(toWrite2, sizeof(toWrite2), &written)));
EXPECT_EQ(written, sizeof(toWrite2));
EXPECT_FALSE(cb->Called());
ASSERT_TRUE(NS_SUCCEEDED(asyncMultiplex->Available(&available)));
ASSERT_NS_SUCCEEDED(asyncMultiplex->Available(&available));
EXPECT_EQ(available, sizeof(toWrite2));
ASSERT_TRUE(NS_SUCCEEDED(pipeOut->Close()));
ASSERT_TRUE(NS_SUCCEEDED(asyncMultiplex->Available(&available)));
ASSERT_NS_SUCCEEDED(pipeOut->Close());
ASSERT_NS_SUCCEEDED(asyncMultiplex->Available(&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.
@ -911,7 +912,7 @@ void TestMultiplexStreamReadWhileWaiting(nsIAsyncInputStream* pipeIn,
NS_SUCCEEDED(asyncMultiplex->Read(toRead2, sizeof(toRead2), &read)));
EXPECT_EQ(read, sizeof(toRead2));
EXPECT_STREQ(toRead2, toWrite2);
ASSERT_TRUE(NS_SUCCEEDED(asyncMultiplex->Available(&available)));
ASSERT_NS_SUCCEEDED(asyncMultiplex->Available(&available));
EXPECT_EQ(available, 5u);
// Read the extra data as well.
@ -920,7 +921,7 @@ void TestMultiplexStreamReadWhileWaiting(nsIAsyncInputStream* pipeIn,
NS_SUCCEEDED(asyncMultiplex->Read(extraRead, sizeof(extraRead), &read)));
EXPECT_EQ(read, sizeof(extraRead));
EXPECT_STREQ(extraRead, "xxxx");
ASSERT_TRUE(NS_SUCCEEDED(asyncMultiplex->Available(&available)));
ASSERT_NS_SUCCEEDED(asyncMultiplex->Available(&available));
EXPECT_EQ(available, 0u);
}

5
xpcom/tests/gtest/TestObserverService.cpp
View file

@ -13,6 +13,7 @@
#include "nsString.h"
#include "nsWeakReference.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/RefPtr.h"
#include "gtest/gtest.h"
@ -132,7 +133,7 @@ TEST(ObserverService, RemoveObserver)
// Remove from non-existent topic.
nsresult rv = svc->RemoveObserver(a, "Bar");
ASSERT_TRUE(NS_FAILED(rv));
ASSERT_NS_FAILED(rv);
// Remove a.
testResult(svc->RemoveObserver(a, "Foo"));
@ -142,7 +143,7 @@ TEST(ObserverService, RemoveObserver)
// Attempt to remove c.
rv = svc->RemoveObserver(c, "Foo");
ASSERT_TRUE(NS_FAILED(rv));
ASSERT_NS_FAILED(rv);
}
TEST(ObserverService, EnumerateEmpty)

87
xpcom/tests/gtest/TestPipes.cpp
View file

@ -7,6 +7,7 @@
#include <algorithm>
#include "gtest/gtest.h"
#include "Helpers.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/ReentrantMonitor.h"
#include "mozilla/Printf.h"
#include "nsCOMPtr.h"
@ -349,17 +350,17 @@ static void RunTests(uint32_t segSize, uint32_t segCount) {
printf("Testing long writes...\n");
}
rv = NS_NewPipe(getter_AddRefs(in), getter_AddRefs(out), segSize, bufSize);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
rv = TestPipe(in, out);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
if (gTrace) {
printf("Testing short writes...\n");
}
rv = NS_NewPipe(getter_AddRefs(in), getter_AddRefs(out), segSize, bufSize);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
rv = TestShortWrites(in, out);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
}
TEST(Pipes, Main)
@ -385,7 +386,7 @@ static void TestPipe2(uint32_t aNumBytes,
nsresult rv = NS_NewPipe(getter_AddRefs(reader), getter_AddRefs(writer),
aSegmentSize, maxSize);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsTArray<char> inputData;
testing::CreateData(aNumBytes, inputData);
@ -441,7 +442,7 @@ static void TestPipeClone(uint32_t aTotalBytes, uint32_t aNumWrites,
nsresult rv =
NS_NewPipe(getter_AddRefs(reader), getter_AddRefs(writer), aSegmentSize,
maxSize, true, false); // non-blocking - reader, writer
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsICloneableInputStream> cloneable = do_QueryInterface(reader);
ASSERT_TRUE(cloneable);
@ -460,7 +461,7 @@ static void TestPipeClone(uint32_t aTotalBytes, uint32_t aNumWrites,
for (uint32_t i = 0; i < aNumInitialClones; ++i) {
nsCOMPtr<nsIInputStream>* clone = streamList.AppendElement();
rv = cloneable->Clone(getter_AddRefs(*clone));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(*clone);
outputDataList.AppendElement();
@ -500,7 +501,7 @@ static void TestPipeClone(uint32_t aTotalBytes, uint32_t aNumWrites,
for (uint32_t i = 0; i < aNumToCloneAfterWrite; ++i) {
nsCOMPtr<nsIInputStream>* clone = streamList.AppendElement();
rv = cloneable->Clone(getter_AddRefs(*clone));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(*clone);
// Initialize the new output data to make whats been read to data for
@ -539,7 +540,7 @@ static void TestPipeClone(uint32_t aTotalBytes, uint32_t aNumWrites,
}
rv = writer->Close();
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsDependentCSubstring inputString(inputData.Elements(), inputData.Length());
@ -634,14 +635,14 @@ TEST(Pipes, Write_AsyncWait)
nsresult rv = NS_NewPipe2(getter_AddRefs(reader), getter_AddRefs(writer),
true, true, // non-blocking - reader, writer
segmentSize, numSegments);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsTArray<char> inputData;
testing::CreateData(segmentSize, inputData);
uint32_t numWritten = 0;
rv = writer->Write(inputData.Elements(), inputData.Length(), &numWritten);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = writer->Write(inputData.Elements(), inputData.Length(), &numWritten);
ASSERT_EQ(NS_BASE_STREAM_WOULD_BLOCK, rv);
@ -650,7 +651,7 @@ TEST(Pipes, Write_AsyncWait)
new testing::OutputStreamCallback();
rv = writer->AsyncWait(cb, 0, 0, nullptr);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_FALSE(cb->Called());
@ -670,18 +671,18 @@ TEST(Pipes, Write_AsyncWait_Clone)
nsresult rv = NS_NewPipe2(getter_AddRefs(reader), getter_AddRefs(writer),
true, true, // non-blocking - reader, writer
segmentSize, numSegments);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIInputStream> clone;
rv = NS_CloneInputStream(reader, getter_AddRefs(clone));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsTArray<char> inputData;
testing::CreateData(segmentSize, inputData);
uint32_t numWritten = 0;
rv = writer->Write(inputData.Elements(), inputData.Length(), &numWritten);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// This attempts to write data beyond the original pipe size limit. It
// should fail since neither side of the clone has been read yet.
@ -692,7 +693,7 @@ TEST(Pipes, Write_AsyncWait_Clone)
new testing::OutputStreamCallback();
rv = writer->AsyncWait(cb, 0, 0, nullptr);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_FALSE(cb->Called());
@ -709,17 +710,17 @@ TEST(Pipes, Write_AsyncWait_Clone)
// other input stream has drained its buffered segments and is ready for more
// data.
rv = writer->Write(inputData.Elements(), inputData.Length(), &numWritten);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Again, this should fail since the origin stream has not been read again.
// The pipe size should still restrict how far ahead we can buffer even
// when there is a cloned stream not being read.
rv = writer->Write(inputData.Elements(), inputData.Length(), &numWritten);
ASSERT_TRUE(NS_FAILED(rv));
ASSERT_NS_FAILED(rv);
cb = new testing::OutputStreamCallback();
rv = writer->AsyncWait(cb, 0, 0, nullptr);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// The write should again be blocked since we have written data and the
// main reader is at its maximum advance buffer.
@ -753,18 +754,18 @@ TEST(Pipes, Write_AsyncWait_Clone_CloseOriginal)
nsresult rv = NS_NewPipe2(getter_AddRefs(reader), getter_AddRefs(writer),
true, true, // non-blocking - reader, writer
segmentSize, numSegments);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIInputStream> clone;
rv = NS_CloneInputStream(reader, getter_AddRefs(clone));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsTArray<char> inputData;
testing::CreateData(segmentSize, inputData);
uint32_t numWritten = 0;
rv = writer->Write(inputData.Elements(), inputData.Length(), &numWritten);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// This attempts to write data beyond the original pipe size limit. It
// should fail since neither side of the clone has been read yet.
@ -775,7 +776,7 @@ TEST(Pipes, Write_AsyncWait_Clone_CloseOriginal)
new testing::OutputStreamCallback();
rv = writer->AsyncWait(cb, 0, 0, nullptr);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_FALSE(cb->Called());
@ -792,17 +793,17 @@ TEST(Pipes, Write_AsyncWait_Clone_CloseOriginal)
// other input stream has drained its buffered segments and is ready for more
// data.
rv = writer->Write(inputData.Elements(), inputData.Length(), &numWritten);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Again, this should fail since the origin stream has not been read again.
// The pipe size should still restrict how far ahead we can buffer even
// when there is a cloned stream not being read.
rv = writer->Write(inputData.Elements(), inputData.Length(), &numWritten);
ASSERT_TRUE(NS_FAILED(rv));
ASSERT_NS_FAILED(rv);
cb = new testing::OutputStreamCallback();
rv = writer->AsyncWait(cb, 0, 0, nullptr);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// The write should again be blocked since we have written data and the
// main reader is at its maximum advance buffer.
@ -819,13 +820,13 @@ TEST(Pipes, Write_AsyncWait_Clone_CloseOriginal)
// And we should not be able to perform a write.
rv = writer->Write(inputData.Elements(), inputData.Length(), &numWritten);
ASSERT_TRUE(NS_FAILED(rv));
ASSERT_NS_FAILED(rv);
// Create another clone stream. Now we have two streams that exceed our
// maximum size limit
nsCOMPtr<nsIInputStream> clone2;
rv = NS_CloneInputStream(clone, getter_AddRefs(clone2));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsTArray<char> expectedCloneData;
expectedCloneData.AppendElements(inputData);
@ -841,12 +842,12 @@ TEST(Pipes, Write_AsyncWait_Clone_CloseOriginal)
// Write again to reach our limit again.
rv = writer->Write(inputData.Elements(), inputData.Length(), &numWritten);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// The stream is again non-writeable.
cb = new testing::OutputStreamCallback();
rv = writer->AsyncWait(cb, 0, 0, nullptr);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_FALSE(cb->Called());
// Close the empty stream. This is different from our previous close since
@ -857,7 +858,7 @@ TEST(Pipes, Write_AsyncWait_Clone_CloseOriginal)
// over our limit.
ASSERT_FALSE(cb->Called());
rv = writer->Write(inputData.Elements(), inputData.Length(), &numWritten);
ASSERT_TRUE(NS_FAILED(rv));
ASSERT_NS_FAILED(rv);
// Finally consume all of the buffered data on the second clone.
expectedCloneData.AppendElements(inputData);
@ -878,7 +879,7 @@ TEST(Pipes, Read_AsyncWait)
nsresult rv = NS_NewPipe2(getter_AddRefs(reader), getter_AddRefs(writer),
true, true, // non-blocking - reader, writer
segmentSize, numSegments);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsTArray<char> inputData;
testing::CreateData(segmentSize, inputData);
@ -886,13 +887,13 @@ TEST(Pipes, Read_AsyncWait)
RefPtr<testing::InputStreamCallback> cb = new testing::InputStreamCallback();
rv = reader->AsyncWait(cb, 0, 0, nullptr);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_FALSE(cb->Called());
uint32_t numWritten = 0;
rv = writer->Write(inputData.Elements(), inputData.Length(), &numWritten);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(cb->Called());
@ -910,11 +911,11 @@ TEST(Pipes, Read_AsyncWait_Clone)
nsresult rv = NS_NewPipe2(getter_AddRefs(reader), getter_AddRefs(writer),
true, true, // non-blocking - reader, writer
segmentSize, numSegments);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIInputStream> clone;
rv = NS_CloneInputStream(reader, getter_AddRefs(clone));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIAsyncInputStream> asyncClone = do_QueryInterface(clone);
ASSERT_TRUE(asyncClone);
@ -927,18 +928,18 @@ TEST(Pipes, Read_AsyncWait_Clone)
RefPtr<testing::InputStreamCallback> cb2 = new testing::InputStreamCallback();
rv = reader->AsyncWait(cb, 0, 0, nullptr);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_FALSE(cb->Called());
rv = asyncClone->AsyncWait(cb2, 0, 0, nullptr);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_FALSE(cb2->Called());
uint32_t numWritten = 0;
rv = writer->Write(inputData.Elements(), inputData.Length(), &numWritten);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(cb->Called());
ASSERT_TRUE(cb2->Called());
@ -980,7 +981,7 @@ void TestCloseDuringRead(uint32_t aSegmentSize, uint32_t aDataSize) {
nsresult rv = NS_NewPipe(getter_AddRefs(reader), getter_AddRefs(writer),
aSegmentSize, maxSize);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsTArray<char> inputData;
@ -988,14 +989,14 @@ void TestCloseDuringRead(uint32_t aSegmentSize, uint32_t aDataSize) {
uint32_t numWritten = 0;
rv = writer->Write(inputData.Elements(), inputData.Length(), &numWritten);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsTArray<char> outputData;
uint32_t numRead = 0;
rv = reader->ReadSegments(CloseDuringReadFunc, &outputData,
inputData.Length(), &numRead);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(inputData.Length(), numRead);
ASSERT_EQ(inputData, outputData);
@ -1019,7 +1020,7 @@ TEST(Pipes, Interfaces)
nsCOMPtr<nsIOutputStream> writer;
nsresult rv = NS_NewPipe(getter_AddRefs(reader), getter_AddRefs(writer));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIAsyncInputStream> readerType1 = do_QueryInterface(reader);
ASSERT_TRUE(readerType1);

3
xpcom/tests/gtest/TestRWLock.cpp
View file

@ -6,6 +6,7 @@
#include "nsThreadUtils.h"
#include "mozilla/Atomics.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/RWLock.h"
#include "mozilla/SyncRunnable.h"
#include "nsIThread.h"
@ -80,7 +81,7 @@ TEST(RWLock, SmokeTest)
// Wait for all the threads to finish.
for (size_t i = 0; i < sNumThreads; ++i) {
nsresult rv = threads[i]->Shutdown();
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
}
EXPECT_EQ(data, (sOuterIterations / sWriteLockIteration) * sNumThreads);

9
xpcom/tests/gtest/TestRacingServiceManager.cpp
View file

@ -15,6 +15,7 @@
#include "prmon.h"
#include "mozilla/Assertions.h"
#include "mozilla/Attributes.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/ReentrantMonitor.h"
@ -215,7 +216,7 @@ TEST(RacingServiceManager, Test)
// Run the classID test
nsCOMPtr<nsIThread> newThread;
rv = NS_NewNamedThread("RacingServMan", getter_AddRefs(newThread), runnable);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
{
ReentrantMonitorAutoEnter mon2(*gReentrantMonitor);
@ -229,7 +230,7 @@ TEST(RacingServiceManager, Test)
}
nsCOMPtr<nsISupports> component(do_GetService(kFactoryCID1, &rv));
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Reset for the contractID test
gMainThreadWaiting = gCreateInstanceCalled = false;
@ -237,7 +238,7 @@ TEST(RacingServiceManager, Test)
component = nullptr;
rv = newThread->Dispatch(runnable, NS_DISPATCH_NORMAL);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
{
ReentrantMonitorAutoEnter mon3(*gReentrantMonitor);
@ -251,7 +252,7 @@ TEST(RacingServiceManager, Test)
}
component = do_GetService(FACTORY_CONTRACTID, &rv);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
NS_RELEASE(gFactory);
}

7
xpcom/tests/gtest/TestSlicedInputStream.cpp
View file

@ -1,5 +1,6 @@
#include "gtest/gtest.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/SlicedInputStream.h"
#include "mozilla/SpinEventLoopUntil.h"
#include "nsCOMPtr.h"
@ -469,7 +470,7 @@ TEST(TestSlicedInputStream, AsyncInputStream)
nsresult rv = NS_NewPipe2(getter_AddRefs(reader), getter_AddRefs(writer),
true, true, // non-blocking - reader, writer
segmentSize, numSegments);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsTArray<char> inputData;
testing::CreateData(segmentSize, inputData);
@ -490,13 +491,13 @@ TEST(TestSlicedInputStream, AsyncInputStream)
RefPtr<testing::InputStreamCallback> cb = new testing::InputStreamCallback();
rv = async->AsyncWait(cb, 0, 0, nullptr);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_FALSE(cb->Called());
uint32_t numWritten = 0;
rv = writer->Write(inputData.Elements(), inputData.Length(), &numWritten);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(cb->Called());

7
xpcom/tests/gtest/TestSnappyStreams.cpp
View file

@ -7,6 +7,7 @@
#include <algorithm>
#include "gtest/gtest.h"
#include "Helpers.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/SnappyCompressOutputStream.h"
#include "mozilla/SnappyUncompressInputStream.h"
#include "nsIPipe.h"
@ -51,7 +52,7 @@ static void TestCompress(uint32_t aNumBytes) {
nsAutoCString outputData;
nsresult rv = NS_ConsumeStream(pipeReader, UINT32_MAX, outputData);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_LT(outputData.Length(), inputData.Length());
}
@ -73,7 +74,7 @@ static void TestCompressUncompress(uint32_t aNumBytes) {
nsAutoCString outputData;
nsresult rv = NS_ConsumeStream(uncompress, UINT32_MAX, outputData);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_EQ(inputData.Length(), outputData.Length());
for (uint32_t i = 0; i < inputData.Length(); ++i) {
@ -87,7 +88,7 @@ static void TestUncompressCorrupt(const char* aCorruptData,
nsresult rv = NS_NewByteInputStream(
getter_AddRefs(source), mozilla::Span(aCorruptData, aCorruptLength),
NS_ASSIGNMENT_DEPEND);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIInputStream> uncompress = new SnappyUncompressInputStream(source);

25
xpcom/tests/gtest/TestStorageStream.cpp
View file

@ -7,6 +7,7 @@
#include <stdlib.h>
#include "gtest/gtest.h"
#include "Helpers.h"
#include "mozilla/gtest/MozAssertions.h"
#include "nsCOMPtr.h"
#include "nsICloneableInputStream.h"
#include "nsIInputStream.h"
@ -20,7 +21,7 @@ void WriteData(nsIOutputStream* aOut, nsTArray<char>& aData, uint32_t aNumBytes,
nsACString& aDataWritten) {
uint32_t n;
nsresult rv = aOut->Write(aData.Elements(), aNumBytes, &n);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
aDataWritten.Append(aData.Elements(), aNumBytes);
}
@ -39,22 +40,22 @@ TEST(StorageStreams, Main)
nsCOMPtr<nsIStorageStream> stor;
rv = NS_NewStorageStream(kData.Length(), UINT32_MAX, getter_AddRefs(stor));
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIOutputStream> out;
rv = stor->GetOutputStream(0, getter_AddRefs(out));
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
WriteData(out, kData, kData.Length(), dataWritten);
WriteData(out, kData, kData.Length(), dataWritten);
rv = out->Close();
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
out = nullptr;
nsCOMPtr<nsIInputStream> in;
rv = stor->NewInputStream(0, getter_AddRefs(in));
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
nsCOMPtr<nsICloneableInputStream> cloneable = do_QueryInterface(in);
ASSERT_TRUE(cloneable != nullptr);
@ -72,7 +73,7 @@ TEST(StorageStreams, Main)
// total written equals 20491 bytes
rv = stor->GetOutputStream(dataWritten.Length(), getter_AddRefs(out));
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
WriteData(out, kData, kData.Length(), dataWritten);
WriteData(out, kData, kData.Length(), dataWritten);
@ -80,12 +81,12 @@ TEST(StorageStreams, Main)
WriteData(out, kData, 11, dataWritten);
rv = out->Close();
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
out = nullptr;
// now, read all
rv = stor->NewInputStream(0, getter_AddRefs(in));
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
testing::ConsumeAndValidateStream(in, dataWritten);
in = nullptr;
@ -104,23 +105,23 @@ TEST(StorageStreams, EarlyInputStream)
nsCOMPtr<nsIStorageStream> stor;
rv = NS_NewStorageStream(kData.Length(), UINT32_MAX, getter_AddRefs(stor));
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
// Get input stream before writing data into the output stream
nsCOMPtr<nsIInputStream> in;
rv = stor->NewInputStream(0, getter_AddRefs(in));
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
// Write data to output stream
nsCOMPtr<nsIOutputStream> out;
rv = stor->GetOutputStream(0, getter_AddRefs(out));
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
WriteData(out, kData, kData.Length(), dataWritten);
WriteData(out, kData, kData.Length(), dataWritten);
rv = out->Close();
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
out = nullptr;
// Should be able to consume input stream

11
xpcom/tests/gtest/TestStringStream.cpp
View file

@ -6,6 +6,7 @@
#include "gtest/gtest.h"
#include "Helpers.h"
#include "mozilla/gtest/MozAssertions.h"
#include "nsICloneableInputStream.h"
#include "nsStringStream.h"
#include "nsTArray.h"
@ -24,7 +25,7 @@ static void TestStringStream(uint32_t aNumBytes) {
nsCOMPtr<nsIInputStream> stream;
nsresult rv = NS_NewCStringInputStream(getter_AddRefs(stream), inputString);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
testing::ConsumeAndValidateStream(stream, inputString);
}
@ -36,7 +37,7 @@ static void TestStringStreamClone(uint32_t aNumBytes) {
nsCOMPtr<nsIInputStream> stream;
nsresult rv = NS_NewCStringInputStream(getter_AddRefs(stream), inputString);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsICloneableInputStream> cloneable = do_QueryInterface(stream);
ASSERT_TRUE(cloneable != nullptr);
@ -85,15 +86,15 @@ TEST(StringStream, CancelInReadSegments)
nsCOMPtr<nsIInputStream> stream;
nsresult rv = NS_NewByteInputStream(
getter_AddRefs(stream), mozilla::Span(buffer, 5), NS_ASSIGNMENT_ADOPT);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
char buf[100];
uint32_t count = 0;
uint64_t available = 0;
rv = stream->Available(&available);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = stream->ReadSegments(CloseStreamThenRead, buf, available, &count);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(count == 5);
ASSERT_TRUE(!strcmp(buf, "test"));
}

3
xpcom/tests/gtest/TestTArray2.cpp
View file

@ -19,6 +19,7 @@
#include "nsIFile.h"
#include "gtest/gtest.h"
#include "mozilla/gtest/MozAssertions.h"
using namespace mozilla;
@ -731,7 +732,7 @@ TEST(TArray, test_comptr_array)
FilePointer f;
tmpDir->Clone(getter_AddRefs(f));
ASSERT_TRUE(f);
ASSERT_FALSE(NS_FAILED(f->AppendNative(nsDependentCString(kNames[i]))));
ASSERT_NS_SUCCEEDED(f->AppendNative(nsDependentCString(kNames[i])));
fileArray.AppendElement(f);
}

17
xpcom/tests/gtest/TestThreadManager.cpp
View file

@ -12,6 +12,7 @@
#include "nsServiceManagerUtils.h"
#include "mozilla/Atomics.h"
#include "gtest/gtest.h"
#include "mozilla/gtest/MozAssertions.h"
using mozilla::Atomic;
using mozilla::Runnable;
@ -85,17 +86,17 @@ TEST(ThreadManager, SpinEventLoopUntilSuccess)
RefPtr<SpinRunnable> spinner = new SpinRunnable(condition);
nsCOMPtr<nsIThread> thread;
rv = NS_NewNamedThread("SpinEventLoop", getter_AddRefs(thread), spinner);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIRunnable> counter = new CountRunnable(count);
for (uint32_t i = 0; i < kRunnablesToDispatch; ++i) {
rv = thread->Dispatch(counter, NS_DISPATCH_NORMAL);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
}
rv = thread->Shutdown();
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_TRUE(NS_SUCCEEDED(spinner->SpinLoopResult()));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_NS_SUCCEEDED(spinner->SpinLoopResult());
}
class ErrorCondition final : public nsINestedEventLoopCondition {
@ -132,15 +133,15 @@ TEST(ThreadManager, SpinEventLoopUntilError)
RefPtr<SpinRunnable> spinner = new SpinRunnable(condition);
nsCOMPtr<nsIThread> thread;
rv = NS_NewNamedThread("SpinEventLoop", getter_AddRefs(thread), spinner);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIRunnable> counter = new CountRunnable(count);
for (uint32_t i = 0; i < kRunnablesToDispatch; ++i) {
rv = thread->Dispatch(counter, NS_DISPATCH_NORMAL);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
}
rv = thread->Shutdown();
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_TRUE(NS_FAILED(spinner->SpinLoopResult()));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_NS_FAILED(spinner->SpinLoopResult());
}

9
xpcom/tests/gtest/TestThreadMetrics.cpp
View file

@ -7,6 +7,7 @@
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include "mozilla/AbstractThread.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/Preferences.h"
#include "mozilla/dom/DocGroup.h"
#include "mozilla/dom/Document.h"
@ -180,7 +181,7 @@ TEST_F(ThreadMetrics, CollectMetrics) {
// Dispatching a runnable that will last for +50ms
RefPtr<TimedRunnable> runnable = new TimedRunnable(25, 25);
rv = Dispatch(runnable);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Flush the queue
ProcessAllEvents();
@ -211,7 +212,7 @@ TEST_F(ThreadMetrics, CollectRecursiveMetrics) {
nsCOMPtr<nsIRunnable> nested = new TimedRunnable(400, 0);
runnable->AddNestedRunnable({nested});
rv = Dispatch(runnable);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Flush the queue
ProcessAllEvents();
@ -249,7 +250,7 @@ TEST_F(ThreadMetrics, CollectMultipleRecursiveMetrics) {
}
rv = Dispatch(runnable);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Flush the queue
ProcessAllEvents();
@ -289,7 +290,7 @@ TEST_F(ThreadMetrics, CollectMultipleRecursiveMetricsWithTwoDocgroups) {
runnable->AddNestedRunnable({nested2});
rv = Dispatch(runnable);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// Flush the queue
ProcessAllEvents();

13
xpcom/tests/gtest/TestThreadPoolListener.cpp
View file

@ -15,6 +15,7 @@
#include "prthread.h"
#include "mozilla/Assertions.h"
#include "mozilla/Attributes.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/ReentrantMonitor.h"
@ -136,19 +137,19 @@ TEST(ThreadPoolListener, Test)
nsCOMPtr<nsIThreadPool> pool = new nsThreadPool();
rv = pool->SetThreadLimit(NUMBER_OF_THREADS);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = pool->SetIdleThreadLimit(NUMBER_OF_THREADS);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
rv = pool->SetIdleThreadTimeout(IDLE_THREAD_TIMEOUT);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIThreadPoolListener> listener = new Listener();
ASSERT_TRUE(listener);
rv = pool->SetListener(listener);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
{
ReentrantMonitorAutoEnter mon(*gReentrantMonitor);
@ -158,7 +159,7 @@ TEST(ThreadPoolListener, Test)
ASSERT_TRUE(runnable);
rv = pool->Dispatch(runnable, NS_DISPATCH_NORMAL);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
}
gAllRunnablesPosted = true;
@ -173,7 +174,7 @@ TEST(ThreadPoolListener, Test)
}
rv = pool->Shutdown();
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
{
ReentrantMonitorAutoEnter mon(*gReentrantMonitor);

19
xpcom/tests/gtest/TestThreads.cpp
View file

@ -13,6 +13,7 @@
#include "nsITargetShutdownTask.h"
#include "nsIThread.h"
#include "nsXPCOM.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/Monitor.h"
#include "mozilla/SyncRunnable.h"
#include "gtest/gtest.h"
@ -26,7 +27,7 @@ class nsRunner final : public Runnable {
NS_IMETHOD Run() override {
nsCOMPtr<nsIThread> thread;
nsresult rv = NS_GetCurrentThread(getter_AddRefs(thread));
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
printf("running %d on thread %p\n", mNum, (void*)thread.get());
// if we don't do something slow, we'll never see the other
@ -51,14 +52,14 @@ TEST(Threads, Main)
nsCOMPtr<nsIThread> runner;
rv = NS_NewNamedThread("TestThreadsMain", getter_AddRefs(runner), event);
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIThread> thread;
rv = NS_GetCurrentThread(getter_AddRefs(thread));
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
rv = runner->Shutdown(); // wait for the runner to die before quitting
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
PR_Sleep(
PR_MillisecondsToInterval(100)); // hopefully the runner will quit here
@ -116,7 +117,7 @@ TEST(Threads, Stress)
nsCOMPtr<nsIThread> t;
nsresult rv = NS_NewNamedThread("StressRunner", getter_AddRefs(t),
new nsStressRunner(k));
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
NS_ADDREF(array[k] = t);
}
@ -167,13 +168,13 @@ class AsyncShutdownWaiter : public Runnable {
rv = NS_NewNamedThread("AsyncShutdownPr", getter_AddRefs(t),
new AsyncShutdownPreparer());
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
lock.Wait();
}
rv = t->AsyncShutdown();
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
return NS_OK;
}
@ -215,14 +216,14 @@ TEST(Threads, AsyncShutdown)
rv = NS_NewNamedThread("AsyncShutdownWt", getter_AddRefs(t),
new AsyncShutdownWaiter());
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
lock.Wait();
}
NS_DispatchToCurrentThread(new SameThreadSentinel());
rv = t->Shutdown();
EXPECT_TRUE(NS_SUCCEEDED(rv));
EXPECT_NS_SUCCEEDED(rv);
delete gAsyncShutdownReadyMonitor;
delete gBeginAsyncShutdownMonitor;

71
xpcom/tests/gtest/TestThrottledEventQueue.cpp
View file

@ -13,6 +13,7 @@
#include "gtest/gtest.h"
#include "mozilla/Attributes.h"
#include "mozilla/CondVar.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/Mutex.h"
#include "mozilla/RefPtr.h"
#include "mozilla/ThrottledEventQueue.h"
@ -123,7 +124,7 @@ TEST(ThrottledEventQueue, RunnableQueue)
Enqueue(queue, [&]() { log += 'c'; });
ASSERT_EQ(log, "");
ASSERT_TRUE(NS_SUCCEEDED(queue->Run()));
ASSERT_NS_SUCCEEDED(queue->Run());
ASSERT_EQ(log, "abc");
}
@ -136,7 +137,7 @@ TEST(ThrottledEventQueue, SimpleDispatch)
ThrottledEventQueue::Create(base, "test queue 1");
Enqueue(throttled, [&]() { log += 'a'; });
ASSERT_TRUE(NS_SUCCEEDED(base->Run()));
ASSERT_NS_SUCCEEDED(base->Run());
ASSERT_EQ(log, "a");
ASSERT_TRUE(base->IsEmpty());
@ -182,7 +183,7 @@ TEST(ThrottledEventQueue, MixedDispatch)
// - the executor again, which runs the second event from the
// ThrottledEventQueue.
ASSERT_EQ(log, "");
ASSERT_TRUE(NS_SUCCEEDED(base->Run()));
ASSERT_NS_SUCCEEDED(base->Run());
ASSERT_EQ(log, "acb");
ASSERT_TRUE(base->IsEmpty());
@ -208,7 +209,7 @@ TEST(ThrottledEventQueue, EnqueueFromRun)
Enqueue(throttled, [&]() { log += 'd'; });
ASSERT_EQ(log, "");
ASSERT_TRUE(NS_SUCCEEDED(base->Run()));
ASSERT_NS_SUCCEEDED(base->Run());
ASSERT_EQ(log, "abdc");
ASSERT_TRUE(base->IsEmpty());
@ -228,14 +229,14 @@ TEST(ThrottledEventQueue, RunFromRun)
Enqueue(throttled, [&]() {
log += '(';
// This should run subsequent events from throttled.
ASSERT_TRUE(NS_SUCCEEDED(base->Run()));
ASSERT_NS_SUCCEEDED(base->Run());
log += ')';
});
Enqueue(throttled, [&]() { log += 'a'; });
ASSERT_EQ(log, "");
ASSERT_TRUE(NS_SUCCEEDED(base->Run()));
ASSERT_NS_SUCCEEDED(base->Run());
ASSERT_EQ(log, "(a)");
ASSERT_TRUE(base->IsEmpty());
@ -256,7 +257,7 @@ TEST(ThrottledEventQueue, DropWhileRunning)
}
ASSERT_EQ(log, "");
ASSERT_TRUE(NS_SUCCEEDED(base->Run()));
ASSERT_NS_SUCCEEDED(base->Run());
ASSERT_EQ(log, "a");
}
@ -289,7 +290,7 @@ TEST(ThrottledEventQueue, AwaitIdle)
nsCOMPtr<nsIThread> thread;
nsresult rv =
NS_NewNamedThread("TEQ AwaitIdle", getter_AddRefs(thread), await);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// We can't guarantee that the thread has reached the AwaitIdle call, but we
// can get pretty close. Either way, it shouldn't affect the behavior of the
@ -304,7 +305,7 @@ TEST(ThrottledEventQueue, AwaitIdle)
ASSERT_FALSE(threadFinished);
}
ASSERT_FALSE(runnableFinished);
ASSERT_TRUE(NS_SUCCEEDED(base->Run()));
ASSERT_NS_SUCCEEDED(base->Run());
ASSERT_TRUE(runnableFinished);
// Wait for the thread to finish.
@ -314,7 +315,7 @@ TEST(ThrottledEventQueue, AwaitIdle)
ASSERT_EQ(dequeue_await, "dequeue await");
}
ASSERT_TRUE(NS_SUCCEEDED(thread->Shutdown()));
ASSERT_NS_SUCCEEDED(thread->Shutdown());
}
TEST(ThrottledEventQueue, AwaitIdleMixed)
@ -376,7 +377,7 @@ TEST(ThrottledEventQueue, AwaitIdleMixed)
ASSERT_EQ(log, "");
}
ASSERT_TRUE(NS_SUCCEEDED(thread->Dispatch(await.forget())));
ASSERT_NS_SUCCEEDED(thread->Dispatch(await.forget()));
// Wait for the thread to be ready to await. We can't be sure it will actually
// be blocking before we get around to draining the event queue, but that's
@ -389,7 +390,7 @@ TEST(ThrottledEventQueue, AwaitIdleMixed)
}
// Let the queue drain.
ASSERT_TRUE(NS_SUCCEEDED(base->Run()));
ASSERT_NS_SUCCEEDED(base->Run());
{
MutexAutoLock lock(mutex);
@ -406,7 +407,7 @@ TEST(ThrottledEventQueue, AwaitIdleMixed)
ASSERT_TRUE(log == "(a)b" || log == "(ab)");
}
ASSERT_TRUE(NS_SUCCEEDED(thread->Shutdown()));
ASSERT_NS_SUCCEEDED(thread->Shutdown());
}
TEST(ThrottledEventQueue, SimplePauseResume)
@ -422,23 +423,23 @@ TEST(ThrottledEventQueue, SimplePauseResume)
Enqueue(throttled, [&]() { log += 'a'; });
ASSERT_EQ(log, "");
ASSERT_TRUE(NS_SUCCEEDED(base->Run()));
ASSERT_NS_SUCCEEDED(base->Run());
ASSERT_EQ(log, "a");
ASSERT_TRUE(NS_SUCCEEDED(throttled->SetIsPaused(true)));
ASSERT_NS_SUCCEEDED(throttled->SetIsPaused(true));
ASSERT_TRUE(throttled->IsPaused());
Enqueue(throttled, [&]() { log += 'b'; });
ASSERT_EQ(log, "a");
ASSERT_TRUE(NS_SUCCEEDED(base->Run()));
ASSERT_NS_SUCCEEDED(base->Run());
ASSERT_EQ(log, "a");
ASSERT_TRUE(NS_SUCCEEDED(throttled->SetIsPaused(false)));
ASSERT_NS_SUCCEEDED(throttled->SetIsPaused(false));
ASSERT_FALSE(throttled->IsPaused());
ASSERT_EQ(log, "a");
ASSERT_TRUE(NS_SUCCEEDED(base->Run()));
ASSERT_NS_SUCCEEDED(base->Run());
ASSERT_EQ(log, "ab");
ASSERT_TRUE(base->IsEmpty());
@ -464,7 +465,7 @@ TEST(ThrottledEventQueue, MixedPauseResume)
Enqueue(base, [&]() { log += 'D'; });
ASSERT_EQ(log, "");
ASSERT_TRUE(NS_SUCCEEDED(base->Run()));
ASSERT_NS_SUCCEEDED(base->Run());
// Since the 'b' event paused the throttled queue, 'c' should not have run.
// but 'D' was enqueued directly on the base, and should have run.
ASSERT_EQ(log, "AbD");
@ -473,11 +474,11 @@ TEST(ThrottledEventQueue, MixedPauseResume)
ASSERT_TRUE(throttled->IsPaused());
Enqueue(base, [&]() { log += 'E'; });
ASSERT_TRUE(NS_SUCCEEDED(throttled->SetIsPaused(false)));
ASSERT_NS_SUCCEEDED(throttled->SetIsPaused(false));
Enqueue(base, [&]() { log += 'F'; });
ASSERT_FALSE(throttled->IsPaused());
ASSERT_TRUE(NS_SUCCEEDED(base->Run()));
ASSERT_NS_SUCCEEDED(base->Run());
// Since we've unpaused, 'c' should be able to run now. The executor should
// have been enqueued between 'E' and 'F'.
ASSERT_EQ(log, "AbDEcF");
@ -499,7 +500,7 @@ TEST(ThrottledEventQueue, AwaitIdlePaused)
RefPtr<ThrottledEventQueue> throttled =
ThrottledEventQueue::Create(base, "test queue 10");
ASSERT_TRUE(NS_SUCCEEDED(throttled->SetIsPaused(true)));
ASSERT_NS_SUCCEEDED(throttled->SetIsPaused(true));
// Put an event in the queue so the AwaitIdle might block. Since throttled is
// paused, this should not enqueue an executor in the base target.
@ -520,7 +521,7 @@ TEST(ThrottledEventQueue, AwaitIdlePaused)
nsCOMPtr<nsIThread> thread;
nsresult rv =
NS_NewNamedThread("AwaitIdlePaused", getter_AddRefs(thread), await);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
// We can't guarantee that the thread has reached the AwaitIdle call, but we
// can get pretty close. Either way, it shouldn't affect the behavior of the
@ -538,14 +539,14 @@ TEST(ThrottledEventQueue, AwaitIdlePaused)
// A paused TEQ contributes no events to its base target. (This is covered by
// other tests...)
ASSERT_TRUE(NS_SUCCEEDED(base->Run()));
ASSERT_NS_SUCCEEDED(base->Run());
ASSERT_TRUE(base->IsEmpty());
ASSERT_FALSE(throttled->IsEmpty());
// Resume and drain the queue.
ASSERT_FALSE(runnableFinished);
ASSERT_TRUE(NS_SUCCEEDED(throttled->SetIsPaused(false)));
ASSERT_TRUE(NS_SUCCEEDED(base->Run()));
ASSERT_NS_SUCCEEDED(throttled->SetIsPaused(false));
ASSERT_NS_SUCCEEDED(base->Run());
ASSERT_TRUE(base->IsEmpty());
ASSERT_TRUE(throttled->IsEmpty());
ASSERT_TRUE(runnableFinished);
@ -557,7 +558,7 @@ TEST(ThrottledEventQueue, AwaitIdlePaused)
ASSERT_EQ(dequeue_await, "dequeue await");
}
ASSERT_TRUE(NS_SUCCEEDED(thread->Shutdown()));
ASSERT_NS_SUCCEEDED(thread->Shutdown());
}
TEST(ThrottledEventQueue, ExecutorTransitions)
@ -568,7 +569,7 @@ TEST(ThrottledEventQueue, ExecutorTransitions)
RefPtr<ThrottledEventQueue> throttled =
ThrottledEventQueue::Create(base, "test queue 11");
ASSERT_TRUE(NS_SUCCEEDED(throttled->SetIsPaused(true)));
ASSERT_NS_SUCCEEDED(throttled->SetIsPaused(true));
// Since we're paused, queueing an event on throttled shouldn't queue the
// executor on the base target.
@ -578,35 +579,35 @@ TEST(ThrottledEventQueue, ExecutorTransitions)
// Resuming throttled should create the executor, since throttled is not
// empty.
ASSERT_TRUE(NS_SUCCEEDED(throttled->SetIsPaused(false)));
ASSERT_NS_SUCCEEDED(throttled->SetIsPaused(false));
ASSERT_EQ(throttled->Length(), 1U);
ASSERT_EQ(base->Length(), 1U);
// Pausing can't remove the executor from the base target since we've already
// queued it there, but it can ensure that it doesn't do anything.
ASSERT_TRUE(NS_SUCCEEDED(throttled->SetIsPaused(true)));
ASSERT_NS_SUCCEEDED(throttled->SetIsPaused(true));
ASSERT_EQ(log, "");
ASSERT_TRUE(NS_SUCCEEDED(base->Run()));
ASSERT_NS_SUCCEEDED(base->Run());
ASSERT_EQ(log, "");
ASSERT_EQ(throttled->Length(), 1U);
ASSERT_EQ(base->Length(), 0U);
// As before, resuming must create the executor, since throttled is not empty.
ASSERT_TRUE(NS_SUCCEEDED(throttled->SetIsPaused(false)));
ASSERT_NS_SUCCEEDED(throttled->SetIsPaused(false));
ASSERT_EQ(throttled->Length(), 1U);
ASSERT_EQ(base->Length(), 1U);
ASSERT_EQ(log, "");
ASSERT_TRUE(NS_SUCCEEDED(base->Run()));
ASSERT_NS_SUCCEEDED(base->Run());
ASSERT_EQ(log, "a");
ASSERT_EQ(throttled->Length(), 0U);
ASSERT_EQ(base->Length(), 0U);
// Since throttled is empty, pausing and resuming now should not enqueue an
// executor.
ASSERT_TRUE(NS_SUCCEEDED(throttled->SetIsPaused(true)));
ASSERT_TRUE(NS_SUCCEEDED(throttled->SetIsPaused(false)));
ASSERT_NS_SUCCEEDED(throttled->SetIsPaused(true));
ASSERT_NS_SUCCEEDED(throttled->SetIsPaused(false));
ASSERT_EQ(throttled->Length(), 0U);
ASSERT_EQ(base->Length(), 0U);
}

3
xpcom/tests/gtest/TestTimers.cpp
View file

@ -15,6 +15,7 @@
#include "prmon.h"
#include "prthread.h"
#include "mozilla/Attributes.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/Services.h"
#include "mozilla/Monitor.h"
@ -883,7 +884,7 @@ TEST(Timers, ClosureCallback)
mon.Notify();
},
50, nsITimer::TYPE_ONE_SHOT, "(test) Timers.ClosureCallback", testThread);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ReentrantMonitorAutoEnter mon(*newMon);
while (!notifiedThread) {

5
xpcom/tests/windows/TestCOM.cpp
View file

@ -8,6 +8,7 @@
#include <stdio.h>
#include "nsISupports.h"
#include "nsCOMPtr.h"
#include "mozilla/gtest/MozAssertions.h"
#include "mozilla/RefPtr.h"
// unknwn.h is needed to build with WIN32_LEAN_AND_MEAN
@ -74,7 +75,7 @@ TEST(TestCOM, WindowsInterop)
RefPtr<nsTestCom> t = new nsTestCom();
IUnknown* iUnknown = nullptr;
nsresult rv = t->QueryInterface(NS_GET_IID(nsISupports), (void**)&iUnknown);
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
ASSERT_TRUE(iUnknown);
// Test we can QI an IUnknown to nsITestCom.
@ -86,7 +87,7 @@ TEST(TestCOM, WindowsInterop)
// Make sure we can call our test function (and the pointer is valid).
rv = iTestCom->Test();
ASSERT_TRUE(NS_SUCCEEDED(rv));
ASSERT_NS_SUCCEEDED(rv);
iUnknown->Release();
iTestCom = nullptr;