diff --git a/caps/tests/gtest/TestNullPrincipalPrecursor.cpp b/caps/tests/gtest/TestNullPrincipalPrecursor.cpp
index 509f9ccf8298..96db5aeffd61 100644
--- a/caps/tests/gtest/TestNullPrincipalPrecursor.cpp
+++ b/caps/tests/gtest/TestNullPrincipalPrecursor.cpp
@@ -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
diff --git a/dom/fs/test/gtest/parent/datamodel/TestFileSystemDataManager.cpp b/dom/fs/test/gtest/parent/datamodel/TestFileSystemDataManager.cpp
index 51232247e0b7..3b2bb30c1a03 100644
--- a/dom/fs/test/gtest/parent/datamodel/TestFileSystemDataManager.cpp
+++ b/dom/fs/test/gtest/parent/datamodel/TestFileSystemDataManager.cpp
@@ -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;
 
diff --git a/dom/media/doctor/test/gtest/TestMultiWriterQueue.cpp b/dom/media/doctor/test/gtest/TestMultiWriterQueue.cpp
index 0c1ea6235c98..35a89c926791 100644
--- a/dom/media/doctor/test/gtest/TestMultiWriterQueue.cpp
+++ b/dom/media/doctor/test/gtest/TestMultiWriterQueue.cpp
@@ -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);
     }
   }
diff --git a/dom/media/gtest/TestCDMStorage.cpp b/dom/media/gtest/TestCDMStorage.cpp
index b4bc3644fb8b..769d1ce41a19 100644
--- a/dom/media/gtest/TestCDMStorage.cpp
+++ b/dom/media/gtest/TestCDMStorage.cpp
@@ -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);
diff --git a/dom/media/gtest/TestGMPCrossOrigin.cpp b/dom/media/gtest/TestGMPCrossOrigin.cpp
index 052e59d4cb24..b9e058c4b3bd 100644
--- a/dom/media/gtest/TestGMPCrossOrigin.cpp
+++ b/dom/media/gtest/TestGMPCrossOrigin.cpp
@@ -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&>(
diff --git a/dom/media/gtest/TestMediaDataDecoder.cpp b/dom/media/gtest/TestMediaDataDecoder.cpp
index 1477c1269938..2930dfb7a19f 100644
--- a/dom/media/gtest/TestMediaDataDecoder.cpp
+++ b/dom/media/gtest/TestMediaDataDecoder.cpp
@@ -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);
diff --git a/dom/media/gtest/mp4_demuxer/TestParser.cpp b/dom/media/gtest/mp4_demuxer/TestParser.cpp
index 7489afdafb92..ae1c6cec7944 100644
--- a/dom/media/gtest/mp4_demuxer/TestParser.cpp
+++ b/dom/media/gtest/mp4_demuxer/TestParser.cpp
@@ -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);
diff --git a/dom/media/mediasource/gtest/TestContainerParser.cpp b/dom/media/mediasource/gtest/TestContainerParser.cpp
index a2feb9ed9eb1..f3bb6d7eda4f 100644
--- a/dom/media/mediasource/gtest/TestContainerParser.cpp
+++ b/dom/media/mediasource/gtest/TestContainerParser.cpp
@@ -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();
diff --git a/dom/security/test/gtest/TestCSPParser.cpp b/dom/security/test/gtest/TestCSPParser.cpp
index 520f08c7bf53..735a6c7502a5 100644
--- a/dom/security/test/gtest/TestCSPParser.cpp
+++ b/dom/security/test/gtest/TestCSPParser.cpp
@@ -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 ========================
diff --git a/editor/txmgr/tests/TestTXMgr.cpp b/editor/txmgr/tests/TestTXMgr.cpp
index f603234ee190..71c6cdadf478 100644
--- a/editor/txmgr/tests/TestTXMgr.cpp
+++ b/editor/txmgr/tests/TestTXMgr.cpp
@@ -7,6 +7,7 @@
 
 #include "nsITransactionManager.h"
 #include "nsComponentManagerUtils.h"
+#include "mozilla/gtest/MozAssertions.h"
 #include "mozilla/Likely.h"
 #include "mozilla/EditTransactionBase.h"
 #include "mozilla/TransactionManager.h"
@@ -513,7 +514,7 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
    *******************************************************************/
 
   rv = mgr->UndoTransaction();
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   /*******************************************************************
    *
@@ -522,7 +523,7 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
    *******************************************************************/
 
   rv = mgr->RedoTransaction();
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   /*******************************************************************
    *
@@ -531,7 +532,7 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
    *******************************************************************/
 
   rv = mgr->SetMaxTransactionCount(-1);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   /*******************************************************************
    *
@@ -540,7 +541,7 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
    *******************************************************************/
 
   rv = mgr->SetMaxTransactionCount(0);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   /*******************************************************************
    *
@@ -549,7 +550,7 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
    *******************************************************************/
 
   rv = mgr->SetMaxTransactionCount(10);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   /*******************************************************************
    *
@@ -558,7 +559,7 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
    *******************************************************************/
 
   rv = mgr->Clear();
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   /*******************************************************************
    *
@@ -568,7 +569,7 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
 
   int32_t numitems;
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   /*******************************************************************
@@ -578,7 +579,7 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
    *******************************************************************/
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   /*******************************************************************
@@ -590,7 +591,7 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
   {
     nsCOMPtr<nsITransaction> tx;
     rv = mgr->PeekUndoStack(getter_AddRefs(tx));
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
     EXPECT_EQ(tx, nullptr);
   }
 
@@ -603,7 +604,7 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
   {
     nsCOMPtr<nsITransaction> tx;
     rv = mgr->PeekRedoStack(getter_AddRefs(tx));
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
     EXPECT_EQ(tx, nullptr);
   }
 
@@ -621,43 +622,43 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
   nsCOMPtr<nsITransaction> u1, u2, r1, r2;
 
   rv = mgr->SetMaxTransactionCount(10);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   tximpl = factory->create(mgr, MERGE_FLAG);
   rv = mgr->DoTransaction(tximpl);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(u1, tximpl);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   for (i = 1; i <= 20; i++) {
     tximpl = factory->create(mgr, NONE_FLAG);
     rv = mgr->DoTransaction(tximpl);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
   }
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(u1, u2);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(r1, r2);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 1);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   rv = mgr->Clear();
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   /*******************************************************************
    *
@@ -669,15 +670,15 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
   for (i = 1; i <= 20; i++) {
     tximpl = factory->create(mgr, NONE_FLAG);
     rv = mgr->DoTransaction(tximpl);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
   }
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 10);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   /*******************************************************************
@@ -690,31 +691,31 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
   u1 = u2 = r1 = r2 = nullptr;
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   for (i = 1; i <= 20; i++) {
     tximpl = factory->create(mgr, TRANSIENT_FLAG);
     rv = mgr->DoTransaction(tximpl);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
   }
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(u1, u2);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(r1, r2);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 10);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   /*******************************************************************
@@ -726,15 +727,15 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
 
   for (i = 1; i <= 4; i++) {
     rv = mgr->UndoTransaction();
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
   }
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 6);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 4);
 
   /*******************************************************************
@@ -746,15 +747,15 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
 
   for (i = 1; i <= 2; ++i) {
     rv = mgr->RedoTransaction();
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
   }
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 8);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 2);
 
   /*******************************************************************
@@ -765,14 +766,14 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
 
   tximpl = factory->create(mgr, NONE_FLAG);
   rv = mgr->DoTransaction(tximpl);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 9);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   /*******************************************************************
@@ -783,26 +784,26 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
 
   for (i = 1; i <= 4; ++i) {
     rv = mgr->UndoTransaction();
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
   }
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 5);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 4);
 
   rv = mgr->Clear();
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   /*******************************************************************
@@ -814,15 +815,15 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
   for (i = 1; i <= 5; i++) {
     tximpl = factory->create(mgr, NONE_FLAG);
     rv = mgr->DoTransaction(tximpl);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
   }
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 5);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   /*******************************************************************
@@ -836,28 +837,28 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
   u1 = u2 = r1 = r2 = nullptr;
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->DoTransaction(tximpl);
   EXPECT_EQ(rv, NS_ERROR_FAILURE);
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(u1, u2);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(r1, r2);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 5);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   /*******************************************************************
@@ -868,33 +869,33 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
 
   tximpl = factory->create(mgr, THROWS_UNDO_ERROR_FLAG);
   rv = mgr->DoTransaction(tximpl);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   u1 = u2 = r1 = r2 = nullptr;
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->UndoTransaction();
   EXPECT_EQ(rv, NS_ERROR_FAILURE);
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(u1, u2);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(r1, r2);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 6);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   /*******************************************************************
@@ -905,7 +906,7 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
 
   tximpl = factory->create(mgr, THROWS_REDO_ERROR_FLAG);
   rv = mgr->DoTransaction(tximpl);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   //
   // Execute a normal transaction to be used in a later test:
@@ -913,7 +914,7 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
 
   tximpl = factory->create(mgr, NONE_FLAG);
   rv = mgr->DoTransaction(tximpl);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   //
   // Undo the 2 transactions just executed.
@@ -921,7 +922,7 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
 
   for (i = 1; i <= 2; ++i) {
     rv = mgr->UndoTransaction();
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
   }
 
   //
@@ -931,28 +932,28 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
   u1 = u2 = r1 = r2 = nullptr;
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->RedoTransaction();
   EXPECT_EQ(rv, NS_ERROR_FAILURE);
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(u1, u2);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(r1, r2);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 6);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 2);
 
   /*******************************************************************
@@ -964,27 +965,27 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
    *******************************************************************/
 
   rv = mgr->SetMaxTransactionCount(0);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   for (i = 1; i <= 20; i++) {
     tximpl = factory->create(mgr, NONE_FLAG);
     rv = mgr->DoTransaction(tximpl);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
 
     rv = mgr->GetNumberOfUndoItems(&numitems);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
     EXPECT_EQ(numitems, 0);
 
     rv = mgr->GetNumberOfRedoItems(&numitems);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
     EXPECT_EQ(numitems, 0);
   }
 
@@ -997,61 +998,61 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
    *******************************************************************/
 
   rv = mgr->SetMaxTransactionCount(-1);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   // Push 20 transactions on the undo stack:
 
   for (i = 1; i <= 20; i++) {
     tximpl = factory->create(mgr, NONE_FLAG);
     rv = mgr->DoTransaction(tximpl);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
 
     rv = mgr->GetNumberOfUndoItems(&numitems);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
     EXPECT_EQ(numitems, i);
 
     rv = mgr->GetNumberOfRedoItems(&numitems);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
     EXPECT_EQ(numitems, 0);
   }
 
   for (i = 1; i <= 10; i++) {
     rv = mgr->UndoTransaction();
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
   }
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 10);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 10);
 
   u1 = u2 = r1 = r2 = nullptr;
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->SetMaxTransactionCount(25);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(u1, u2);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(r1, r2);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 10);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 10);
 
   /*******************************************************************
@@ -1065,28 +1066,28 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
   u1 = u2 = r1 = r2 = nullptr;
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->SetMaxTransactionCount(15);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(u1, u2);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(r1, r2);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 5);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 10);
 
   /*******************************************************************
@@ -1100,28 +1101,28 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
   u1 = u2 = r1 = r2 = nullptr;
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->SetMaxTransactionCount(5);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_FALSE(u2);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(r1, r2);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 5);
 
   /*******************************************************************
@@ -1132,39 +1133,39 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_test(TestTransactionFactory* factory) {
    *******************************************************************/
 
   rv = mgr->SetMaxTransactionCount(-1);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   // Push 20 transactions on the undo stack:
 
   for (i = 1; i <= 20; i++) {
     tximpl = factory->create(mgr, NONE_FLAG);
     rv = mgr->DoTransaction(tximpl);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
 
     rv = mgr->GetNumberOfUndoItems(&numitems);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
     EXPECT_EQ(numitems, i);
 
     rv = mgr->GetNumberOfRedoItems(&numitems);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
     EXPECT_EQ(numitems, 0);
   }
 
   for (i = 1; i <= 10; i++) {
     rv = mgr->UndoTransaction();
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
   }
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 10);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 10);
 
   rv = mgr->Clear();
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 }
 
 TEST(TestTXMgr, SimpleTest)
@@ -1237,14 +1238,14 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_batch_test(
    *******************************************************************/
 
   nsresult rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   rv = mgr->EndBatch(false);
   EXPECT_EQ(rv, NS_ERROR_FAILURE);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   /*******************************************************************
@@ -1255,21 +1256,21 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_batch_test(
    *******************************************************************/
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   rv = mgr->BeginBatch(nullptr);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   rv = mgr->EndBatch(false);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   int32_t i;
@@ -1283,23 +1284,23 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_batch_test(
    *******************************************************************/
 
   rv = mgr->BeginBatch(nullptr);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   for (i = 1; i <= 20; i++) {
     tximpl = factory->create(mgr, NONE_FLAG);
     rv = mgr->DoTransaction(tximpl);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
   }
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   rv = mgr->EndBatch(false);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 1);
 
   nsCOMPtr<nsITransaction> u1, u2, r1, r2;
@@ -1312,37 +1313,37 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_batch_test(
    *******************************************************************/
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->BeginBatch(nullptr);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   for (i = 1; i <= 20; i++) {
     tximpl = factory->create(mgr, TRANSIENT_FLAG);
     rv = mgr->DoTransaction(tximpl);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
   }
 
   rv = mgr->EndBatch(false);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(u1, u2);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(r1, r2);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 1);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   /*******************************************************************
@@ -1353,49 +1354,49 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_batch_test(
    *******************************************************************/
 
   rv = mgr->BeginBatch(nullptr);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   tximpl = factory->create(mgr, NONE_FLAG);
   rv = mgr->DoTransaction(tximpl);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 1);
 
   rv = mgr->BeginBatch(nullptr);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   tximpl = factory->create(mgr, NONE_FLAG);
   rv = mgr->DoTransaction(tximpl);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 1);
 
   rv = mgr->BeginBatch(nullptr);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   tximpl = factory->create(mgr, NONE_FLAG);
   rv = mgr->DoTransaction(tximpl);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 1);
 
   rv = mgr->EndBatch(false);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->EndBatch(false);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->EndBatch(false);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 2);
 
   /*******************************************************************
@@ -1407,15 +1408,15 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_batch_test(
 
   for (i = 1; i <= 2; ++i) {
     rv = mgr->UndoTransaction();
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
   }
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 2);
 
   /*******************************************************************
@@ -1427,15 +1428,15 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_batch_test(
 
   for (i = 1; i <= 2; ++i) {
     rv = mgr->RedoTransaction();
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
   }
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 2);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   /*******************************************************************
@@ -1446,14 +1447,14 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_batch_test(
    *******************************************************************/
 
   rv = mgr->UndoTransaction();
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 1);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 1);
 
   /*******************************************************************
@@ -1467,11 +1468,11 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_batch_test(
   EXPECT_EQ(rv, NS_ERROR_FAILURE);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 1);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 1);
 
   /*******************************************************************
@@ -1483,25 +1484,25 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_batch_test(
    *******************************************************************/
 
   rv = mgr->BeginBatch(nullptr);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 1);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 1);
 
   rv = mgr->EndBatch(false);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 1);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 1);
 
   /*******************************************************************
@@ -1511,31 +1512,31 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_batch_test(
    *******************************************************************/
 
   rv = mgr->BeginBatch(nullptr);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   for (i = 1; i <= 20; i++) {
     tximpl = factory->create(mgr, NONE_FLAG);
     rv = mgr->DoTransaction(tximpl);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
   }
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 1);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 1);
 
   rv = mgr->EndBatch(false);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 2);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   /*******************************************************************
@@ -1548,14 +1549,14 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_batch_test(
   // transaction on the undo stack, and one on the redo stack!
 
   rv = mgr->UndoTransaction();
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 1);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 1);
 
   /*******************************************************************
@@ -1569,34 +1570,34 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_batch_test(
   u1 = u2 = r1 = r2 = nullptr;
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->BeginBatch(nullptr);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->DoTransaction(tximpl);
   EXPECT_EQ(rv, NS_ERROR_FAILURE);
 
   rv = mgr->EndBatch(false);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(u1, u2);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(r1, r2);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 1);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 1);
 
   /*******************************************************************
@@ -1608,39 +1609,39 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_batch_test(
   tximpl = factory->create(mgr, THROWS_UNDO_ERROR_FLAG);
 
   rv = mgr->BeginBatch(nullptr);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->DoTransaction(tximpl);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->EndBatch(false);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   u1 = u2 = r1 = r2 = nullptr;
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->UndoTransaction();
   EXPECT_EQ(rv, NS_ERROR_FAILURE);
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(u1, u2);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(r1, r2);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 2);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   /*******************************************************************
@@ -1652,13 +1653,13 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_batch_test(
   tximpl = factory->create(mgr, THROWS_REDO_ERROR_FLAG);
 
   rv = mgr->BeginBatch(nullptr);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->DoTransaction(tximpl);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->EndBatch(false);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   //
   // Execute a normal transaction to be used in a later test:
@@ -1666,7 +1667,7 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_batch_test(
 
   tximpl = factory->create(mgr, NONE_FLAG);
   rv = mgr->DoTransaction(tximpl);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   //
   // Undo the 2 transactions just executed.
@@ -1674,7 +1675,7 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_batch_test(
 
   for (i = 1; i <= 2; ++i) {
     rv = mgr->UndoTransaction();
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
   }
 
   //
@@ -1684,28 +1685,28 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_batch_test(
   u1 = u2 = r1 = r2 = nullptr;
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r1));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->RedoTransaction();
   EXPECT_EQ(rv, NS_ERROR_FAILURE);
 
   rv = mgr->PeekUndoStack(getter_AddRefs(u2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(u1, u2);
 
   rv = mgr->PeekRedoStack(getter_AddRefs(r2));
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(r1, r2);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 2);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 2);
 
   /*******************************************************************
@@ -1717,34 +1718,34 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_batch_test(
    *******************************************************************/
 
   rv = mgr->SetMaxTransactionCount(0);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 0);
 
   for (i = 1; i <= 20; i++) {
     tximpl = factory->create(mgr, NONE_FLAG);
 
     rv = mgr->BeginBatch(nullptr);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
 
     rv = mgr->DoTransaction(tximpl);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
 
     rv = mgr->EndBatch(false);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
 
     rv = mgr->GetNumberOfUndoItems(&numitems);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
     EXPECT_EQ(numitems, 0);
 
     rv = mgr->GetNumberOfRedoItems(&numitems);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
     EXPECT_EQ(numitems, 0);
   }
 
@@ -1756,7 +1757,7 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_batch_test(
    *******************************************************************/
 
   rv = mgr->SetMaxTransactionCount(-1);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 
   // Push 20 transactions on the undo stack:
 
@@ -1764,37 +1765,37 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void quick_batch_test(
     tximpl = factory->create(mgr, NONE_FLAG);
 
     rv = mgr->BeginBatch(nullptr);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
 
     rv = mgr->DoTransaction(tximpl);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
 
     rv = mgr->EndBatch(false);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
 
     rv = mgr->GetNumberOfUndoItems(&numitems);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
     EXPECT_EQ(numitems, i);
 
     rv = mgr->GetNumberOfRedoItems(&numitems);
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
     EXPECT_EQ(numitems, 0);
   }
 
   for (i = 1; i <= 10; i++) {
     rv = mgr->UndoTransaction();
-    EXPECT_TRUE(NS_SUCCEEDED(rv));
+    EXPECT_NS_SUCCEEDED(rv);
   }
   rv = mgr->GetNumberOfUndoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 10);
 
   rv = mgr->GetNumberOfRedoItems(&numitems);
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
   EXPECT_EQ(numitems, 10);
 
   rv = mgr->Clear();
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 }
 
 TEST(TestTXMgr, SimpleBatchTest)
@@ -1870,7 +1871,7 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void stress_test(TestTransactionFactory* factory,
     for (j = 1; j <= i; j++) {
       RefPtr<TestTransaction> tximpl = factory->create(mgr, NONE_FLAG);
       rv = mgr->DoTransaction(tximpl);
-      EXPECT_TRUE(NS_SUCCEEDED(rv));
+      EXPECT_NS_SUCCEEDED(rv);
     }
 
     /*******************************************************************
@@ -1881,7 +1882,7 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void stress_test(TestTransactionFactory* factory,
 
     for (j = 1; j <= i; j++) {
       rv = mgr->UndoTransaction();
-      EXPECT_TRUE(NS_SUCCEEDED(rv));
+      EXPECT_NS_SUCCEEDED(rv);
     }
 
     /*******************************************************************
@@ -1892,7 +1893,7 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void stress_test(TestTransactionFactory* factory,
 
     for (j = 1; j <= i; j++) {
       rv = mgr->RedoTransaction();
-      EXPECT_TRUE(NS_SUCCEEDED(rv));
+      EXPECT_NS_SUCCEEDED(rv);
     }
 
     /*******************************************************************
@@ -1905,12 +1906,12 @@ MOZ_CAN_RUN_SCRIPT_BOUNDARY void stress_test(TestTransactionFactory* factory,
 
     for (j = 1; j <= i; j++) {
       rv = mgr->UndoTransaction();
-      EXPECT_TRUE(NS_SUCCEEDED(rv));
+      EXPECT_NS_SUCCEEDED(rv);
     }
   }
 
   rv = mgr->Clear();
-  EXPECT_TRUE(NS_SUCCEEDED(rv));
+  EXPECT_NS_SUCCEEDED(rv);
 }
 
 TEST(TestTXMgr, SimpleStressTest)
diff --git a/gfx/tests/gtest/TestVsync.cpp b/gfx/tests/gtest/TestVsync.cpp
index 45db77582f41..7249e7d26cc2 100644
--- a/gfx/tests/gtest/TestVsync.cpp
+++ b/gfx/tests/gtest/TestVsync.cpp
@@ -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;
diff --git a/image/test/gtest/Common.cpp b/image/test/gtest/Common.cpp
index 1e79084d39b5..5f815a59e8c1 100644
--- a/image/test/gtest/Common.cpp
+++ b/image/test/gtest/Common.cpp
@@ -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);
 }
 
diff --git a/image/test/gtest/Common.h b/image/test/gtest/Common.h
index 623ca476aa61..ba56816c3738 100644
--- a/image/test/gtest/Common.h
+++ b/image/test/gtest/Common.h
@@ -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) {
diff --git a/image/test/gtest/TestAnimationFrameBuffer.cpp b/image/test/gtest/TestAnimationFrameBuffer.cpp
index 222543c5d6b5..78186e506651 100644
--- a/image/test/gtest/TestAnimationFrameBuffer.cpp
+++ b/image/test/gtest/TestAnimationFrameBuffer.cpp
@@ -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.
diff --git a/image/test/gtest/TestDecodeToSurface.cpp b/image/test/gtest/TestDecodeToSurface.cpp
index 6e41dbf61695..7872b629c11e 100644
--- a/image/test/gtest/TestDecodeToSurface.cpp
+++ b/image/test/gtest/TestDecodeToSurface.cpp
@@ -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());
 
diff --git a/image/test/gtest/TestDecoders.cpp b/image/test/gtest/TestDecoders.cpp
index 51af034d3869..3d1d5e091cdc 100644
--- a/image/test/gtest/TestDecoders.cpp
+++ b/image/test/gtest/TestDecoders.cpp
@@ -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) {
diff --git a/image/test/gtest/TestFrameAnimator.cpp b/image/test/gtest/TestFrameAnimator.cpp
index a0c54f3f0944..8bc913b752cb 100644
--- a/image/test/gtest/TestFrameAnimator.cpp
+++ b/image/test/gtest/TestFrameAnimator.cpp
@@ -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
diff --git a/image/test/gtest/TestLoader.cpp b/image/test/gtest/TestLoader.cpp
index 02ada2720301..d18302f37abf 100644
--- a/image/test/gtest/TestLoader.cpp
+++ b/image/test/gtest/TestLoader.cpp
@@ -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());
   }
 }
diff --git a/image/test/gtest/TestMetadata.cpp b/image/test/gtest/TestMetadata.cpp
index 0d1f78b32da3..d230bf42b9df 100644
--- a/image/test/gtest/TestMetadata.cpp
+++ b/image/test/gtest/TestMetadata.cpp
@@ -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);
diff --git a/image/test/gtest/TestSourceBuffer.cpp b/image/test/gtest/TestSourceBuffer.cpp
index 5c937becb80b..478ab5661055 100644
--- a/image/test/gtest/TestSourceBuffer.cpp
+++ b/image/test/gtest/TestSourceBuffer.cpp
@@ -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);
 }
diff --git a/image/test/gtest/TestSurfaceCache.cpp b/image/test/gtest/TestSurfaceCache.cpp
index 45c73c5a13fa..53193b1a88f5 100644
--- a/image/test/gtest/TestSurfaceCache.cpp
+++ b/image/test/gtest/TestSurfaceCache.cpp
@@ -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);
diff --git a/image/test/gtest/TestSurfacePipeIntegration.cpp b/image/test/gtest/TestSurfacePipeIntegration.cpp
index 24e446e7a1c9..1a2769818cfd 100644
--- a/image/test/gtest/TestSurfacePipeIntegration.cpp
+++ b/image/test/gtest/TestSurfacePipeIntegration.cpp
@@ -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);
 
diff --git a/intl/locale/tests/gtest/TestAppDateTimeFormat.cpp b/intl/locale/tests/gtest/TestAppDateTimeFormat.cpp
index eb5a464891af..e9167af6c623 100644
--- a/intl/locale/tests/gtest/TestAppDateTimeFormat.cpp
+++ b/intl/locale/tests/gtest/TestAppDateTimeFormat.cpp
@@ -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());
   }
 }
diff --git a/intl/locale/tests/gtest/TestOSPreferences.cpp b/intl/locale/tests/gtest/TestOSPreferences.cpp
index 45ca5fee32db..e98bf2502502 100644
--- a/intl/locale/tests/gtest/TestOSPreferences.cpp
+++ b/intl/locale/tests/gtest/TestOSPreferences.cpp
@@ -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);
 }
diff --git a/ipc/gtest/TestDataPipe.cpp b/ipc/gtest/TestDataPipe.cpp
index 26a2cc8d1d55..340da7c2180b 100644
--- a/ipc/gtest/TestDataPipe.cpp
+++ b/ipc/gtest/TestDataPipe.cpp
@@ -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);
 }
diff --git a/netwerk/test/gtest/TestBase64Stream.cpp b/netwerk/test/gtest/TestBase64Stream.cpp
index 37f5cb824eb7..d5fd46ee0c51 100644
--- a/netwerk/test/gtest/TestBase64Stream.cpp
+++ b/netwerk/test/gtest/TestBase64Stream.cpp
@@ -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"));
   }
diff --git a/netwerk/test/gtest/TestBind.cpp b/netwerk/test/gtest/TestBind.cpp
index dcc4c2dfe8bf..2b37745dbc0c 100644
--- a/netwerk/test/gtest/TestBind.cpp
+++ b/netwerk/test/gtest/TestBind.cpp
@@ -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);
diff --git a/netwerk/test/gtest/TestCookie.cpp b/netwerk/test/gtest/TestCookie.cpp
index dde9cb035012..a92ed616fec5 100644
--- a/netwerk/test/gtest/TestCookie.cpp
+++ b/netwerk/test/gtest/TestCookie.cpp
@@ -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);
diff --git a/netwerk/test/gtest/TestLinkHeader.cpp b/netwerk/test/gtest/TestLinkHeader.cpp
index 403091ed21d4..fe3e1baf8698 100644
--- a/netwerk/test/gtest/TestLinkHeader.cpp
+++ b/netwerk/test/gtest/TestLinkHeader.cpp
@@ -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(
diff --git a/netwerk/test/gtest/TestNamedPipeService.cpp b/netwerk/test/gtest/TestNamedPipeService.cpp
index af87f9a0744c..b91a17a93e1a 100644
--- a/netwerk/test/gtest/TestNamedPipeService.cpp
+++ b/netwerk/test/gtest/TestNamedPipeService.cpp
@@ -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));
 }
diff --git a/netwerk/test/gtest/TestUDPSocket.cpp b/netwerk/test/gtest/TestUDPSocket.cpp
index d99c13328315..e4f4985549ed 100644
--- a/netwerk/test/gtest/TestUDPSocket.cpp
+++ b/netwerk/test/gtest/TestUDPSocket.cpp
@@ -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
diff --git a/security/manager/ssl/tests/gtest/HMACTest.cpp b/security/manager/ssl/tests/gtest/HMACTest.cpp
index a3840f37aa5b..679c1011247a 100644
--- a/security/manager/ssl/tests/gtest/HMACTest.cpp
+++ b/security/manager/ssl/tests/gtest/HMACTest.cpp
@@ -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]);
diff --git a/startupcache/test/TestStartupCache.cpp b/startupcache/test/TestStartupCache.cpp
index 28e758c6a5e3..d60bbcb8c70e 100644
--- a/startupcache/test/TestStartupCache.cpp
+++ b/startupcache/test/TestStartupCache.cpp
@@ -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));
 }
diff --git a/toolkit/components/antitracking/test/gtest/TestStoragePrincipalHelper.cpp b/toolkit/components/antitracking/test/gtest/TestStoragePrincipalHelper.cpp
index f57b820ff6eb..44959e4dc8b6 100644
--- a/toolkit/components/antitracking/test/gtest/TestStoragePrincipalHelper.cpp
+++ b/toolkit/components/antitracking/test/gtest/TestStoragePrincipalHelper.cpp
@@ -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);
 }
 
diff --git a/toolkit/components/telemetry/geckoview/gtest/TestGeckoViewStreaming.cpp b/toolkit/components/telemetry/geckoview/gtest/TestGeckoViewStreaming.cpp
index 740cb783e7ab..ebaa7099a818 100644
--- a/toolkit/components/telemetry/geckoview/gtest/TestGeckoViewStreaming.cpp
+++ b/toolkit/components/telemetry/geckoview/gtest/TestGeckoViewStreaming.cpp
@@ -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));
diff --git a/toolkit/components/telemetry/tests/gtest/TelemetryTestHelpers.cpp b/toolkit/components/telemetry/tests/gtest/TelemetryTestHelpers.cpp
index 77c86267676a..c8119587b184 100644
--- a/toolkit/components/telemetry/tests/gtest/TelemetryTestHelpers.cpp
+++ b/toolkit/components/telemetry/tests/gtest/TelemetryTestHelpers.cpp
@@ -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.";
 
diff --git a/toolkit/components/url-classifier/tests/gtest/Common.h b/toolkit/components/url-classifier/tests/gtest/Common.h
index 97b81144c36e..df8798a17cc3 100644
--- a/toolkit/components/url-classifier/tests/gtest/Common.h
+++ b/toolkit/components/url-classifier/tests/gtest/Common.h
@@ -11,6 +11,7 @@
 #include "nsTArray.h"
 
 #include "gtest/gtest.h"
+#include "mozilla/gtest/MozAssertions.h"
 
 using namespace mozilla::safebrowsing;
 
diff --git a/toolkit/components/url-classifier/tests/gtest/TestFindFullHash.cpp b/toolkit/components/url-classifier/tests/gtest/TestFindFullHash.cpp
index 43084cd5e913..a3dc6fcc41b7 100644
--- a/toolkit/components/url-classifier/tests/gtest/TestFindFullHash.cpp
+++ b/toolkit/components/url-classifier/tests/gtest/TestFindFullHash.cpp
@@ -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);
diff --git a/toolkit/components/url-classifier/tests/gtest/TestUrlClassifierTableUpdateV4.cpp b/toolkit/components/url-classifier/tests/gtest/TestUrlClassifierTableUpdateV4.cpp
index ac068bc229f8..779b1fd315fe 100644
--- a/toolkit/components/url-classifier/tests/gtest/TestUrlClassifierTableUpdateV4.cpp
+++ b/toolkit/components/url-classifier/tests/gtest/TestUrlClassifierTableUpdateV4.cpp
@@ -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,
diff --git a/toolkit/components/url-classifier/tests/gtest/TestVariableLengthPrefixSet.cpp b/toolkit/components/url-classifier/tests/gtest/TestVariableLengthPrefixSet.cpp
index 92c7d25cbeb1..6eb36a12d248 100644
--- a/toolkit/components/url-classifier/tests/gtest/TestVariableLengthPrefixSet.cpp
+++ b/toolkit/components/url-classifier/tests/gtest/TestVariableLengthPrefixSet.cpp
@@ -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
diff --git a/toolkit/xre/dllservices/tests/gtest/TestDLLBlocklist.cpp b/toolkit/xre/dllservices/tests/gtest/TestDLLBlocklist.cpp
index c1eca0c10259..331e01735460 100644
--- a/toolkit/xre/dllservices/tests/gtest/TestDLLBlocklist.cpp
+++ b/toolkit/xre/dllservices/tests/gtest/TestDLLBlocklist.cpp
@@ -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;
 }
 
diff --git a/toolkit/xre/dllservices/tests/gtest/TestUntrustedModules.cpp b/toolkit/xre/dllservices/tests/gtest/TestUntrustedModules.cpp
index 2c6da40477a2..b0eec470da35 100644
--- a/toolkit/xre/dllservices/tests/gtest/TestUntrustedModules.cpp
+++ b/toolkit/xre/dllservices/tests/gtest/TestUntrustedModules.cpp
@@ -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));
                   });
 }
 
diff --git a/toolkit/xre/test/gtest/TestAssembleCommandLineWin.cpp b/toolkit/xre/test/gtest/TestAssembleCommandLineWin.cpp
index 6831303de633..26e96413078d 100644
--- a/toolkit/xre/test/gtest/TestAssembleCommandLineWin.cpp
+++ b/toolkit/xre/test/gtest/TestAssembleCommandLineWin.cpp
@@ -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);
diff --git a/tools/profiler/tests/gtest/GeckoProfiler.cpp b/tools/profiler/tests/gtest/GeckoProfiler.cpp
index e814d63dc34b..f2b335c1204c 100644
--- a/tools/profiler/tests/gtest/GeckoProfiler.cpp
+++ b/tools/profiler/tests/gtest/GeckoProfiler.cpp
@@ -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();
 
diff --git a/uriloader/preload/gtest/TestFetchPreloader.cpp b/uriloader/preload/gtest/TestFetchPreloader.cpp
index a889b20b588b..3bd9fafa7f2d 100644
--- a/uriloader/preload/gtest/TestFetchPreloader.cpp
+++ b/uriloader/preload/gtest/TestFetchPreloader.cpp
@@ -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
diff --git a/xpcom/tests/gtest/Helpers.cpp b/xpcom/tests/gtest/Helpers.cpp
index 4b830c0fbdd7..043dce4edcdc 100644
--- a/xpcom/tests/gtest/Helpers.cpp
+++ b/xpcom/tests/gtest/Helpers.cpp
@@ -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));
 }
diff --git a/xpcom/tests/gtest/TestAtoms.cpp b/xpcom/tests/gtest/TestAtoms.cpp
index c4b5db8c90c7..7e0181bd3dce 100644
--- a/xpcom/tests/gtest/TestAtoms.cpp
+++ b/xpcom/tests/gtest/TestAtoms.cpp
@@ -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();
diff --git a/xpcom/tests/gtest/TestAutoRefCnt.cpp b/xpcom/tests/gtest/TestAutoRefCnt.cpp
index 2accfef40638..92cc0d253803 100644
--- a/xpcom/tests/gtest/TestAutoRefCnt.cpp
+++ b/xpcom/tests/gtest/TestAutoRefCnt.cpp
@@ -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();
diff --git a/xpcom/tests/gtest/TestAvailableMemoryWatcherMac.cpp b/xpcom/tests/gtest/TestAvailableMemoryWatcherMac.cpp
index ce02ec35b61c..cbd564b7db10 100644
--- a/xpcom/tests/gtest/TestAvailableMemoryWatcherMac.cpp
+++ b/xpcom/tests/gtest/TestAvailableMemoryWatcherMac.cpp
@@ -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);
   }
 };
 
diff --git a/xpcom/tests/gtest/TestAvailableMemoryWatcherWin.cpp b/xpcom/tests/gtest/TestAvailableMemoryWatcherWin.cpp
index 8259fce899dc..409d547aaa6a 100644
--- a/xpcom/tests/gtest/TestAvailableMemoryWatcherWin.cpp
+++ b/xpcom/tests/gtest/TestAvailableMemoryWatcherWin.cpp
@@ -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);
   }
 };
 
diff --git a/xpcom/tests/gtest/TestBase64.cpp b/xpcom/tests/gtest/TestBase64.cpp
index 34b4a26a730e..4c34f7272cf4 100644
--- a/xpcom/tests/gtest/TestBase64.cpp
+++ b/xpcom/tests/gtest/TestBase64.cpp
@@ -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);
 }
 
diff --git a/xpcom/tests/gtest/TestCOMPtr.cpp b/xpcom/tests/gtest/TestCOMPtr.cpp
index 34f06c9db9c1..01fde5632afb 100644
--- a/xpcom/tests/gtest/TestCOMPtr.cpp
+++ b/xpcom/tests/gtest/TestCOMPtr.cpp
@@ -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);
 }
 
diff --git a/xpcom/tests/gtest/TestCloneInputStream.cpp b/xpcom/tests/gtest/TestCloneInputStream.cpp
index 551ac1940457..ea57aa993835 100644
--- a/xpcom/tests/gtest/TestCloneInputStream.cpp
+++ b/xpcom/tests/gtest/TestCloneInputStream.cpp
@@ -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);
 }
diff --git a/xpcom/tests/gtest/TestDelayedRunnable.cpp b/xpcom/tests/gtest/TestDelayedRunnable.cpp
index 2f52d1debbcf..2fdd45079d86 100644
--- a/xpcom/tests/gtest/TestDelayedRunnable.cpp
+++ b/xpcom/tests/gtest/TestDelayedRunnable.cpp
@@ -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();
diff --git a/xpcom/tests/gtest/TestFile.cpp b/xpcom/tests/gtest/TestFile.cpp
index e5babebdc57f..c1ec3166216a 100644
--- a/xpcom/tests/gtest/TestFile.cpp
+++ b/xpcom/tests/gtest/TestFile.cpp
@@ -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;
   }
 
diff --git a/xpcom/tests/gtest/TestFileNTFSSpecialPaths.cpp b/xpcom/tests/gtest/TestFileNTFSSpecialPaths.cpp
index ba98c67dd71e..39b73a71480b 100644
--- a/xpcom/tests/gtest/TestFileNTFSSpecialPaths.cpp
+++ b/xpcom/tests/gtest/TestFileNTFSSpecialPaths.cpp
@@ -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;
 }
diff --git a/xpcom/tests/gtest/TestMultiplexInputStream.cpp b/xpcom/tests/gtest/TestMultiplexInputStream.cpp
index 921366c002f6..546d1b8fb71f 100644
--- a/xpcom/tests/gtest/TestMultiplexInputStream.cpp
+++ b/xpcom/tests/gtest/TestMultiplexInputStream.cpp
@@ -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);
 }
 
diff --git a/xpcom/tests/gtest/TestObserverService.cpp b/xpcom/tests/gtest/TestObserverService.cpp
index 9ff2332b24d0..4126815f1fc1 100644
--- a/xpcom/tests/gtest/TestObserverService.cpp
+++ b/xpcom/tests/gtest/TestObserverService.cpp
@@ -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)
diff --git a/xpcom/tests/gtest/TestPipes.cpp b/xpcom/tests/gtest/TestPipes.cpp
index b00baa17d08b..c69af75e9e9d 100644
--- a/xpcom/tests/gtest/TestPipes.cpp
+++ b/xpcom/tests/gtest/TestPipes.cpp
@@ -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);
diff --git a/xpcom/tests/gtest/TestRWLock.cpp b/xpcom/tests/gtest/TestRWLock.cpp
index 481400163bbb..eee392f7090d 100644
--- a/xpcom/tests/gtest/TestRWLock.cpp
+++ b/xpcom/tests/gtest/TestRWLock.cpp
@@ -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);
diff --git a/xpcom/tests/gtest/TestRacingServiceManager.cpp b/xpcom/tests/gtest/TestRacingServiceManager.cpp
index 06fbabb3e4fa..ad6c08d97b10 100644
--- a/xpcom/tests/gtest/TestRacingServiceManager.cpp
+++ b/xpcom/tests/gtest/TestRacingServiceManager.cpp
@@ -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);
 }
diff --git a/xpcom/tests/gtest/TestSlicedInputStream.cpp b/xpcom/tests/gtest/TestSlicedInputStream.cpp
index 2ce9c22cc10a..d465c4977f00 100644
--- a/xpcom/tests/gtest/TestSlicedInputStream.cpp
+++ b/xpcom/tests/gtest/TestSlicedInputStream.cpp
@@ -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());
 
diff --git a/xpcom/tests/gtest/TestSnappyStreams.cpp b/xpcom/tests/gtest/TestSnappyStreams.cpp
index e4559bc987c6..6b68dbb40b94 100644
--- a/xpcom/tests/gtest/TestSnappyStreams.cpp
+++ b/xpcom/tests/gtest/TestSnappyStreams.cpp
@@ -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);
 
diff --git a/xpcom/tests/gtest/TestStorageStream.cpp b/xpcom/tests/gtest/TestStorageStream.cpp
index 8cfc16dc1b50..f92cb986ba73 100644
--- a/xpcom/tests/gtest/TestStorageStream.cpp
+++ b/xpcom/tests/gtest/TestStorageStream.cpp
@@ -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
diff --git a/xpcom/tests/gtest/TestStringStream.cpp b/xpcom/tests/gtest/TestStringStream.cpp
index b9ef198d1487..8314c3e74cb0 100644
--- a/xpcom/tests/gtest/TestStringStream.cpp
+++ b/xpcom/tests/gtest/TestStringStream.cpp
@@ -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"));
 }
diff --git a/xpcom/tests/gtest/TestTArray2.cpp b/xpcom/tests/gtest/TestTArray2.cpp
index e4dc2a303217..bc64ef1e0559 100644
--- a/xpcom/tests/gtest/TestTArray2.cpp
+++ b/xpcom/tests/gtest/TestTArray2.cpp
@@ -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);
   }
 
diff --git a/xpcom/tests/gtest/TestThreadManager.cpp b/xpcom/tests/gtest/TestThreadManager.cpp
index c10ea43b04c8..41279e104ca9 100644
--- a/xpcom/tests/gtest/TestThreadManager.cpp
+++ b/xpcom/tests/gtest/TestThreadManager.cpp
@@ -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());
 }
diff --git a/xpcom/tests/gtest/TestThreadMetrics.cpp b/xpcom/tests/gtest/TestThreadMetrics.cpp
index 77e160c4c060..1a8e94b932af 100644
--- a/xpcom/tests/gtest/TestThreadMetrics.cpp
+++ b/xpcom/tests/gtest/TestThreadMetrics.cpp
@@ -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();
diff --git a/xpcom/tests/gtest/TestThreadPoolListener.cpp b/xpcom/tests/gtest/TestThreadPoolListener.cpp
index cb36b8543609..2ca4fa26f1c5 100644
--- a/xpcom/tests/gtest/TestThreadPoolListener.cpp
+++ b/xpcom/tests/gtest/TestThreadPoolListener.cpp
@@ -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);
diff --git a/xpcom/tests/gtest/TestThreads.cpp b/xpcom/tests/gtest/TestThreads.cpp
index 62aa29d0a209..4f2e0d7a5906 100644
--- a/xpcom/tests/gtest/TestThreads.cpp
+++ b/xpcom/tests/gtest/TestThreads.cpp
@@ -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;
diff --git a/xpcom/tests/gtest/TestThrottledEventQueue.cpp b/xpcom/tests/gtest/TestThrottledEventQueue.cpp
index 7dc7ba7adc8a..64f34ff14f1c 100644
--- a/xpcom/tests/gtest/TestThrottledEventQueue.cpp
+++ b/xpcom/tests/gtest/TestThrottledEventQueue.cpp
@@ -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);
 }
diff --git a/xpcom/tests/gtest/TestTimers.cpp b/xpcom/tests/gtest/TestTimers.cpp
index ae4c075794dd..74a9ae0da1f1 100644
--- a/xpcom/tests/gtest/TestTimers.cpp
+++ b/xpcom/tests/gtest/TestTimers.cpp
@@ -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) {
diff --git a/xpcom/tests/windows/TestCOM.cpp b/xpcom/tests/windows/TestCOM.cpp
index 7d4f2a38679b..49f67db83545 100644
--- a/xpcom/tests/windows/TestCOM.cpp
+++ b/xpcom/tests/windows/TestCOM.cpp
@@ -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;