Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2226 insertions, 0 deletions

diff --git a/xpcom/tests/gtest/TestThreadUtils.cpp b/xpcom/tests/gtest/TestThreadUtils.cpp
new file mode 100644
index 0000000000..2b9ff97192
--- /dev/null
+++ b/xpcom/tests/gtest/TestThreadUtils.cpp
@@ -0,0 +1,2226 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * 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 <type_traits>
+
+#include "nsComponentManagerUtils.h"
+#include "nsIThread.h"
+#include "nsThreadUtils.h"
+#include "mozilla/IdleTaskRunner.h"
+#include "mozilla/RefCounted.h"
+#include "mozilla/SpinEventLoopUntil.h"
+#include "mozilla/UniquePtr.h"
+
+#include "gtest/gtest.h"
+
+using namespace mozilla;
+
+enum {
+  TEST_CALL_VOID_ARG_VOID_RETURN,
+  TEST_CALL_VOID_ARG_VOID_RETURN_CONST,
+  TEST_CALL_VOID_ARG_NONVOID_RETURN,
+  TEST_CALL_NONVOID_ARG_VOID_RETURN,
+  TEST_CALL_NONVOID_ARG_NONVOID_RETURN,
+  TEST_CALL_NONVOID_ARG_VOID_RETURN_EXPLICIT,
+  TEST_CALL_NONVOID_ARG_NONVOID_RETURN_EXPLICIT,
+#ifdef HAVE_STDCALL
+  TEST_STDCALL_VOID_ARG_VOID_RETURN,
+  TEST_STDCALL_VOID_ARG_NONVOID_RETURN,
+  TEST_STDCALL_NONVOID_ARG_VOID_RETURN,
+  TEST_STDCALL_NONVOID_ARG_NONVOID_RETURN,
+  TEST_STDCALL_NONVOID_ARG_NONVOID_RETURN_EXPLICIT,
+#endif
+  TEST_CALL_NEWTHREAD_SUICIDAL,
+  MAX_TESTS
+};
+
+bool gRunnableExecuted[MAX_TESTS];
+
+class nsFoo : public nsISupports {
+  NS_DECL_ISUPPORTS
+  nsresult DoFoo(bool* aBool) {
+    *aBool = true;
+    return NS_OK;
+  }
+
+ private:
+  virtual ~nsFoo() = default;
+};
+
+NS_IMPL_ISUPPORTS0(nsFoo)
+
+class TestSuicide : public mozilla::Runnable {
+ public:
+  TestSuicide() : mozilla::Runnable("TestSuicide") {}
+  NS_IMETHOD Run() override {
+    // Runs first time on thread "Suicide", then dies on MainThread
+    if (!NS_IsMainThread()) {
+      mThread = do_GetCurrentThread();
+      NS_DispatchToMainThread(this);
+      return NS_OK;
+    }
+    MOZ_RELEASE_ASSERT(mThread);
+    mThread->Shutdown();
+    gRunnableExecuted[TEST_CALL_NEWTHREAD_SUICIDAL] = true;
+    return NS_OK;
+  }
+
+ private:
+  nsCOMPtr<nsIThread> mThread;
+};
+
+class nsBar : public nsISupports {
+  virtual ~nsBar() = default;
+
+ public:
+  NS_DECL_ISUPPORTS
+  void DoBar1(void) {
+    gRunnableExecuted[TEST_CALL_VOID_ARG_VOID_RETURN] = true;
+  }
+  void DoBar1Const(void) const {
+    gRunnableExecuted[TEST_CALL_VOID_ARG_VOID_RETURN_CONST] = true;
+  }
+  nsresult DoBar2(void) {
+    gRunnableExecuted[TEST_CALL_VOID_ARG_NONVOID_RETURN] = true;
+    return NS_OK;
+  }
+  void DoBar3(nsFoo* aFoo) {
+    aFoo->DoFoo(&gRunnableExecuted[TEST_CALL_NONVOID_ARG_VOID_RETURN]);
+  }
+  nsresult DoBar4(nsFoo* aFoo) {
+    return aFoo->DoFoo(
+        &gRunnableExecuted[TEST_CALL_NONVOID_ARG_NONVOID_RETURN]);
+  }
+  void DoBar5(nsFoo* aFoo) {
+    if (aFoo)
+      gRunnableExecuted[TEST_CALL_NONVOID_ARG_VOID_RETURN_EXPLICIT] = true;
+  }
+  nsresult DoBar6(char* aFoo) {
+    if (strlen(aFoo))
+      gRunnableExecuted[TEST_CALL_NONVOID_ARG_NONVOID_RETURN_EXPLICIT] = true;
+    return NS_OK;
+  }
+#ifdef HAVE_STDCALL
+  void __stdcall DoBar1std(void) {
+    gRunnableExecuted[TEST_STDCALL_VOID_ARG_VOID_RETURN] = true;
+  }
+  nsresult __stdcall DoBar2std(void) {
+    gRunnableExecuted[TEST_STDCALL_VOID_ARG_NONVOID_RETURN] = true;
+    return NS_OK;
+  }
+  void __stdcall DoBar3std(nsFoo* aFoo) {
+    aFoo->DoFoo(&gRunnableExecuted[TEST_STDCALL_NONVOID_ARG_VOID_RETURN]);
+  }
+  nsresult __stdcall DoBar4std(nsFoo* aFoo) {
+    return aFoo->DoFoo(
+        &gRunnableExecuted[TEST_STDCALL_NONVOID_ARG_NONVOID_RETURN]);
+  }
+  void __stdcall DoBar5std(nsFoo* aFoo) {
+    if (aFoo)
+      gRunnableExecuted[TEST_STDCALL_NONVOID_ARG_VOID_RETURN_EXPLICIT] = true;
+  }
+  nsresult __stdcall DoBar6std(char* aFoo) {
+    if (strlen(aFoo))
+      gRunnableExecuted[TEST_CALL_NONVOID_ARG_VOID_RETURN_EXPLICIT] = true;
+    return NS_OK;
+  }
+#endif
+};
+
+NS_IMPL_ISUPPORTS0(nsBar)
+
+struct TestCopyWithNoMove {
+  explicit TestCopyWithNoMove(int* aCopyCounter) : mCopyCounter(aCopyCounter) {}
+  TestCopyWithNoMove(const TestCopyWithNoMove& a)
+      : mCopyCounter(a.mCopyCounter) {
+    *mCopyCounter += 1;
+  };
+  // No 'move' declaration, allows passing object by rvalue copy.
+  // Destructor nulls member variable...
+  ~TestCopyWithNoMove() { mCopyCounter = nullptr; }
+  // ... so we can check that the object is called when still alive.
+  void operator()() { MOZ_RELEASE_ASSERT(mCopyCounter); }
+  int* mCopyCounter;
+};
+struct TestCopyWithDeletedMove {
+  explicit TestCopyWithDeletedMove(int* aCopyCounter)
+      : mCopyCounter(aCopyCounter) {}
+  TestCopyWithDeletedMove(const TestCopyWithDeletedMove& a)
+      : mCopyCounter(a.mCopyCounter) {
+    *mCopyCounter += 1;
+  };
+  // Deleted move prevents passing by rvalue (even if copy would work)
+  TestCopyWithDeletedMove(TestCopyWithDeletedMove&&) = delete;
+  ~TestCopyWithDeletedMove() { mCopyCounter = nullptr; }
+  void operator()() { MOZ_RELEASE_ASSERT(mCopyCounter); }
+  int* mCopyCounter;
+};
+struct TestMove {
+  explicit TestMove(int* aMoveCounter) : mMoveCounter(aMoveCounter) {}
+  TestMove(const TestMove&) = delete;
+  TestMove(TestMove&& a) : mMoveCounter(a.mMoveCounter) {
+    a.mMoveCounter = nullptr;
+    *mMoveCounter += 1;
+  }
+  ~TestMove() { mMoveCounter = nullptr; }
+  void operator()() { MOZ_RELEASE_ASSERT(mMoveCounter); }
+  int* mMoveCounter;
+};
+struct TestCopyMove {
+  TestCopyMove(int* aCopyCounter, int* aMoveCounter)
+      : mCopyCounter(aCopyCounter), mMoveCounter(aMoveCounter) {}
+  TestCopyMove(const TestCopyMove& a)
+      : mCopyCounter(a.mCopyCounter), mMoveCounter(a.mMoveCounter) {
+    *mCopyCounter += 1;
+  };
+  TestCopyMove(TestCopyMove&& a)
+      : mCopyCounter(a.mCopyCounter), mMoveCounter(a.mMoveCounter) {
+    a.mMoveCounter = nullptr;
+    *mMoveCounter += 1;
+  }
+  ~TestCopyMove() {
+    mCopyCounter = nullptr;
+    mMoveCounter = nullptr;
+  }
+  void operator()() {
+    MOZ_RELEASE_ASSERT(mCopyCounter);
+    MOZ_RELEASE_ASSERT(mMoveCounter);
+  }
+  int* mCopyCounter;
+  int* mMoveCounter;
+};
+
+struct TestRefCounted : RefCounted<TestRefCounted> {
+  MOZ_DECLARE_REFCOUNTED_TYPENAME(TestRefCounted);
+};
+
+static void Expect(const char* aContext, int aCounter, int aMaxExpected) {
+  EXPECT_LE(aCounter, aMaxExpected) << aContext;
+}
+
+static void ExpectRunnableName(Runnable* aRunnable, const char* aExpectedName) {
+#ifdef MOZ_COLLECTING_RUNNABLE_TELEMETRY
+  nsAutoCString name;
+  EXPECT_TRUE(NS_SUCCEEDED(aRunnable->GetName(name))) << "Runnable::GetName()";
+  EXPECT_TRUE(name.EqualsASCII(aExpectedName)) << "Verify Runnable name";
+#endif
+}
+
+struct BasicRunnableFactory {
+  static constexpr bool SupportsCopyWithDeletedMove = true;
+
+  template <typename Function>
+  static auto Create(const char* aName, Function&& aFunc) {
+    return NS_NewRunnableFunction(aName, std::forward<Function>(aFunc));
+  }
+};
+
+struct CancelableRunnableFactory {
+  static constexpr bool SupportsCopyWithDeletedMove = false;
+
+  template <typename Function>
+  static auto Create(const char* aName, Function&& aFunc) {
+    return NS_NewCancelableRunnableFunction(aName,
+                                            std::forward<Function>(aFunc));
+  }
+};
+
+template <typename RunnableFactory>
+static void TestRunnableFactory(bool aNamed) {
+  // Test RunnableFactory with copyable-only function object.
+  {
+    int copyCounter = 0;
+    {
+      nsCOMPtr<nsIRunnable> trackedRunnable;
+      {
+        TestCopyWithNoMove tracker(&copyCounter);
+        trackedRunnable = aNamed ? RunnableFactory::Create("unused", tracker)
+                                 : RunnableFactory::Create(
+                                       "TestNewRunnableFunction", tracker);
+        // Original 'tracker' is destroyed here.
+      }
+      // Verify that the runnable contains a non-destroyed function object.
+      trackedRunnable->Run();
+    }
+    Expect(
+        "RunnableFactory with copyable-only (and no move) function, "
+        "copies",
+        copyCounter, 1);
+  }
+  {
+    int copyCounter = 0;
+    {
+      nsCOMPtr<nsIRunnable> trackedRunnable;
+      {
+        // Passing as rvalue, but using copy.
+        // (TestCopyWithDeletedMove wouldn't allow this.)
+        trackedRunnable =
+            aNamed ? RunnableFactory::Create("unused",
+                                             TestCopyWithNoMove(&copyCounter))
+                   : RunnableFactory::Create("TestNewRunnableFunction",
+                                             TestCopyWithNoMove(&copyCounter));
+      }
+      trackedRunnable->Run();
+    }
+    Expect(
+        "RunnableFactory with copyable-only (and no move) function "
+        "rvalue, copies",
+        copyCounter, 1);
+  }
+  if constexpr (RunnableFactory::SupportsCopyWithDeletedMove) {
+    int copyCounter = 0;
+    {
+      nsCOMPtr<nsIRunnable> trackedRunnable;
+      {
+        TestCopyWithDeletedMove tracker(&copyCounter);
+        trackedRunnable = aNamed ? RunnableFactory::Create("unused", tracker)
+                                 : RunnableFactory::Create(
+                                       "TestNewRunnableFunction", tracker);
+      }
+      trackedRunnable->Run();
+    }
+    Expect(
+        "RunnableFactory with copyable-only (and deleted move) "
+        "function, copies",
+        copyCounter, 1);
+  }
+
+  // Test RunnableFactory with movable-only function object.
+  {
+    int moveCounter = 0;
+    {
+      nsCOMPtr<nsIRunnable> trackedRunnable;
+      {
+        TestMove tracker(&moveCounter);
+        trackedRunnable =
+            aNamed ? RunnableFactory::Create("unused", std::move(tracker))
+                   : RunnableFactory::Create("TestNewRunnableFunction",
+                                             std::move(tracker));
+      }
+      trackedRunnable->Run();
+    }
+    Expect("RunnableFactory with movable-only function, moves", moveCounter, 1);
+  }
+  {
+    int moveCounter = 0;
+    {
+      nsCOMPtr<nsIRunnable> trackedRunnable;
+      {
+        trackedRunnable =
+            aNamed ? RunnableFactory::Create("unused", TestMove(&moveCounter))
+                   : RunnableFactory::Create("TestNewRunnableFunction",
+                                             TestMove(&moveCounter));
+      }
+      trackedRunnable->Run();
+    }
+    Expect("RunnableFactory with movable-only function rvalue, moves",
+           moveCounter, 1);
+  }
+
+  // Test RunnableFactory with copyable&movable function object.
+  {
+    int copyCounter = 0;
+    int moveCounter = 0;
+    {
+      nsCOMPtr<nsIRunnable> trackedRunnable;
+      {
+        TestCopyMove tracker(&copyCounter, &moveCounter);
+        trackedRunnable =
+            aNamed ? RunnableFactory::Create("unused", std::move(tracker))
+                   : RunnableFactory::Create("TestNewRunnableFunction",
+                                             std::move(tracker));
+      }
+      trackedRunnable->Run();
+    }
+    Expect("RunnableFactory with copyable&movable function, copies",
+           copyCounter, 0);
+    Expect("RunnableFactory with copyable&movable function, moves", moveCounter,
+           1);
+  }
+  {
+    int copyCounter = 0;
+    int moveCounter = 0;
+    {
+      nsCOMPtr<nsIRunnable> trackedRunnable;
+      {
+        trackedRunnable =
+            aNamed ? RunnableFactory::Create(
+                         "unused", TestCopyMove(&copyCounter, &moveCounter))
+                   : RunnableFactory::Create(
+                         "TestNewRunnableFunction",
+                         TestCopyMove(&copyCounter, &moveCounter));
+      }
+      trackedRunnable->Run();
+    }
+    Expect("RunnableFactory with copyable&movable function rvalue, copies",
+           copyCounter, 0);
+    Expect("RunnableFactory with copyable&movable function rvalue, moves",
+           moveCounter, 1);
+  }
+
+  // Test RunnableFactory with copyable-only lambda capture.
+  {
+    int copyCounter = 0;
+    {
+      nsCOMPtr<nsIRunnable> trackedRunnable;
+      {
+        TestCopyWithNoMove tracker(&copyCounter);
+        // Expect 2 copies (here -> local lambda -> runnable lambda).
+        trackedRunnable =
+            aNamed
+                ? RunnableFactory::Create("unused",
+                                          [tracker]() mutable { tracker(); })
+                : RunnableFactory::Create("TestNewRunnableFunction",
+                                          [tracker]() mutable { tracker(); });
+      }
+      trackedRunnable->Run();
+    }
+    Expect(
+        "RunnableFactory with copyable-only (and no move) capture, "
+        "copies",
+        copyCounter, 2);
+  }
+  {
+    int copyCounter = 0;
+    {
+      nsCOMPtr<nsIRunnable> trackedRunnable;
+      {
+        TestCopyWithDeletedMove tracker(&copyCounter);
+        // Expect 2 copies (here -> local lambda -> runnable lambda).
+        trackedRunnable =
+            aNamed
+                ? RunnableFactory::Create("unused",
+                                          [tracker]() mutable { tracker(); })
+                : RunnableFactory::Create("TestNewRunnableFunction",
+                                          [tracker]() mutable { tracker(); });
+      }
+      trackedRunnable->Run();
+    }
+    Expect(
+        "RunnableFactory with copyable-only (and deleted move) capture, "
+        "copies",
+        copyCounter, 2);
+  }
+
+  // Note: Not possible to use move-only captures.
+  // (Until we can use C++14 generalized lambda captures)
+
+  // Test RunnableFactory with copyable&movable lambda capture.
+  {
+    int copyCounter = 0;
+    int moveCounter = 0;
+    {
+      nsCOMPtr<nsIRunnable> trackedRunnable;
+      {
+        TestCopyMove tracker(&copyCounter, &moveCounter);
+        trackedRunnable =
+            aNamed
+                ? RunnableFactory::Create("unused",
+                                          [tracker]() mutable { tracker(); })
+                : RunnableFactory::Create("TestNewRunnableFunction",
+                                          [tracker]() mutable { tracker(); });
+        // Expect 1 copy (here -> local lambda) and 1 move (local -> runnable
+        // lambda).
+      }
+      trackedRunnable->Run();
+    }
+    Expect("RunnableFactory with copyable&movable capture, copies", copyCounter,
+           1);
+    Expect("RunnableFactory with copyable&movable capture, moves", moveCounter,
+           1);
+  }
+}
+
+TEST(ThreadUtils, NewRunnableFunction)
+{ TestRunnableFactory<BasicRunnableFactory>(/*aNamed*/ false); }
+
+TEST(ThreadUtils, NewNamedRunnableFunction)
+{
+  // The named overload shall behave identical to the non-named counterpart.
+  TestRunnableFactory<BasicRunnableFactory>(/*aNamed*/ true);
+
+  // Test naming.
+  {
+    const char* expectedName = "NamedRunnable";
+    RefPtr<Runnable> NamedRunnable =
+        NS_NewRunnableFunction(expectedName, [] {});
+    ExpectRunnableName(NamedRunnable, expectedName);
+  }
+}
+
+TEST(ThreadUtils, NewCancelableRunnableFunction)
+{ TestRunnableFactory<CancelableRunnableFactory>(/*aNamed*/ false); }
+
+TEST(ThreadUtils, NewNamedCancelableRunnableFunction)
+{
+  // The named overload shall behave identical to the non-named counterpart.
+  TestRunnableFactory<CancelableRunnableFactory>(/*aNamed*/ true);
+
+  // Test naming.
+  {
+    const char* expectedName = "NamedRunnable";
+    RefPtr<Runnable> NamedRunnable =
+        NS_NewCancelableRunnableFunction(expectedName, [] {});
+    ExpectRunnableName(NamedRunnable, expectedName);
+  }
+
+  // Test release on cancelation.
+  {
+    auto foo = MakeRefPtr<TestRefCounted>();
+    bool ran = false;
+
+    RefPtr<CancelableRunnable> func =
+        NS_NewCancelableRunnableFunction("unused", [foo, &ran] { ran = true; });
+
+    EXPECT_EQ(foo->refCount(), 2u);
+    func->Cancel();
+
+    EXPECT_EQ(foo->refCount(), 1u);
+    EXPECT_FALSE(ran);
+  }
+
+  // Test no-op after cancelation.
+  {
+    auto foo = MakeRefPtr<TestRefCounted>();
+    bool ran = false;
+
+    RefPtr<CancelableRunnable> func =
+        NS_NewCancelableRunnableFunction("unused", [foo, &ran] { ran = true; });
+
+    EXPECT_EQ(foo->refCount(), 2u);
+    func->Cancel();
+    func->Run();
+
+    EXPECT_FALSE(ran);
+  }
+}
+
+static void TestNewRunnableMethod(bool aNamed) {
+  memset(gRunnableExecuted, false, MAX_TESTS * sizeof(bool));
+  // Scope the smart ptrs so that the runnables need to hold on to whatever they
+  // need
+  {
+    RefPtr<nsFoo> foo = new nsFoo();
+    RefPtr<nsBar> bar = new nsBar();
+    RefPtr<const nsBar> constBar = bar;
+
+    // This pointer will be freed at the end of the block
+    // Do not dereference this pointer in the runnable method!
+    RefPtr<nsFoo> rawFoo = new nsFoo();
+
+    // Read only string. Dereferencing in runnable method to check this works.
+    char* message = (char*)"Test message";
+
+    {
+      auto bar = MakeRefPtr<nsBar>();
+
+      NS_DispatchToMainThread(
+          aNamed ? NewRunnableMethod("unused", std::move(bar), &nsBar::DoBar1)
+                 : NewRunnableMethod("nsBar::DoBar1", std::move(bar),
+                                     &nsBar::DoBar1));
+    }
+
+    NS_DispatchToMainThread(
+        aNamed ? NewRunnableMethod("unused", bar, &nsBar::DoBar1)
+               : NewRunnableMethod("nsBar::DoBar1", bar, &nsBar::DoBar1));
+    NS_DispatchToMainThread(
+        aNamed ? NewRunnableMethod("unused", constBar, &nsBar::DoBar1Const)
+               : NewRunnableMethod("nsBar::DoBar1Const", constBar,
+                                   &nsBar::DoBar1Const));
+    NS_DispatchToMainThread(
+        aNamed ? NewRunnableMethod("unused", bar, &nsBar::DoBar2)
+               : NewRunnableMethod("nsBar::DoBar2", bar, &nsBar::DoBar2));
+    NS_DispatchToMainThread(
+        aNamed ? NewRunnableMethod<RefPtr<nsFoo>>("unused", bar, &nsBar::DoBar3,
+                                                  foo)
+               : NewRunnableMethod<RefPtr<nsFoo>>("nsBar::DoBar3", bar,
+                                                  &nsBar::DoBar3, foo));
+    NS_DispatchToMainThread(
+        aNamed ? NewRunnableMethod<RefPtr<nsFoo>>("unused", bar, &nsBar::DoBar4,
+                                                  foo)
+               : NewRunnableMethod<RefPtr<nsFoo>>("nsBar::DoBar4", bar,
+                                                  &nsBar::DoBar4, foo));
+    NS_DispatchToMainThread(
+        aNamed
+            ? NewRunnableMethod<nsFoo*>("unused", bar, &nsBar::DoBar5, rawFoo)
+            : NewRunnableMethod<nsFoo*>("nsBar::DoBar5", bar, &nsBar::DoBar5,
+                                        rawFoo));
+    NS_DispatchToMainThread(
+        aNamed
+            ? NewRunnableMethod<char*>("unused", bar, &nsBar::DoBar6, message)
+            : NewRunnableMethod<char*>("nsBar::DoBar6", bar, &nsBar::DoBar6,
+                                       message));
+#ifdef HAVE_STDCALL
+    NS_DispatchToMainThread(
+        aNamed ? NewRunnableMethod("unused", bar, &nsBar::DoBar1std)
+               : NewRunnableMethod(bar, &nsBar::DoBar1std));
+    NS_DispatchToMainThread(
+        aNamed ? NewRunnableMethod("unused", bar, &nsBar::DoBar2std)
+               : NewRunnableMethod(bar, &nsBar::DoBar2std));
+    NS_DispatchToMainThread(
+        aNamed ? NewRunnableMethod<RefPtr<nsFoo>>("unused", bar,
+                                                  &nsBar::DoBar3std, foo)
+               : NewRunnableMethod<RefPtr<nsFoo>>(bar, &nsBar::DoBar3std, foo));
+    NS_DispatchToMainThread(
+        aNamed ? NewRunnableMethod<RefPtr<nsFoo>>("unused", bar,
+                                                  &nsBar::DoBar4std, foo)
+               : NewRunnableMethod<RefPtr<nsFoo>>(bar, &nsBar::DoBar4std, foo));
+    NS_DispatchToMainThread(
+        aNamed ? NewRunnableMethod<nsFoo*>("unused", bar, &nsBar::DoBar5std,
+                                           rawFoo)
+               : NewRunnableMethod<nsFoo*>(bar, &nsBar::DoBar5std, rawFoo));
+    NS_DispatchToMainThread(
+        aNamed ? NewRunnableMethod<char*>("unused", bar, &nsBar::DoBar6std,
+                                          message)
+               : NewRunnableMethod<char*>(bar, &nsBar::DoBar6std, message));
+#endif
+  }
+
+  // Spin the event loop
+  NS_ProcessPendingEvents(nullptr);
+
+  // Now test a suicidal event in NS_New(Named)Thread
+  nsCOMPtr<nsIThread> thread;
+  NS_NewNamedThread("SuicideThread", getter_AddRefs(thread), new TestSuicide());
+  ASSERT_TRUE(thread);
+
+  while (!gRunnableExecuted[TEST_CALL_NEWTHREAD_SUICIDAL]) {
+    NS_ProcessPendingEvents(nullptr);
+  }
+
+  for (uint32_t i = 0; i < MAX_TESTS; i++) {
+    EXPECT_TRUE(gRunnableExecuted[i]) << "Error in test " << i;
+  }
+}
+
+TEST(ThreadUtils, RunnableMethod)
+{ TestNewRunnableMethod(/* aNamed */ false); }
+
+TEST(ThreadUtils, NamedRunnableMethod)
+{
+  // The named overloads shall behave identical to the non-named counterparts.
+  TestNewRunnableMethod(/* aNamed */ true);
+
+  // Test naming.
+  {
+    RefPtr<nsFoo> foo = new nsFoo();
+    const char* expectedName = "NamedRunnable";
+    bool unused;
+    RefPtr<Runnable> NamedRunnable =
+        NewRunnableMethod<bool*>(expectedName, foo, &nsFoo::DoFoo, &unused);
+    ExpectRunnableName(NamedRunnable, expectedName);
+  }
+}
+
+class IdleObjectWithoutSetDeadline final {
+ public:
+  NS_INLINE_DECL_REFCOUNTING(IdleObjectWithoutSetDeadline)
+  IdleObjectWithoutSetDeadline() : mRunnableExecuted(false) {}
+  void Method() { mRunnableExecuted = true; }
+  bool mRunnableExecuted;
+
+ private:
+  ~IdleObjectWithoutSetDeadline() = default;
+};
+
+class IdleObjectParentWithSetDeadline {
+ public:
+  IdleObjectParentWithSetDeadline() : mSetDeadlineCalled(false) {}
+  void SetDeadline(TimeStamp aDeadline) { mSetDeadlineCalled = true; }
+  bool mSetDeadlineCalled;
+};
+
+class IdleObjectInheritedSetDeadline final
+    : public IdleObjectParentWithSetDeadline {
+ public:
+  NS_INLINE_DECL_REFCOUNTING(IdleObjectInheritedSetDeadline)
+  IdleObjectInheritedSetDeadline() : mRunnableExecuted(false) {}
+  void Method() { mRunnableExecuted = true; }
+  bool mRunnableExecuted;
+
+ private:
+  ~IdleObjectInheritedSetDeadline() = default;
+};
+
+class IdleObject final {
+ public:
+  NS_INLINE_DECL_REFCOUNTING(IdleObject)
+  IdleObject() {
+    for (uint32_t index = 0; index < ArrayLength(mRunnableExecuted); ++index) {
+      mRunnableExecuted[index] = false;
+      mSetIdleDeadlineCalled = false;
+    }
+  }
+  void SetDeadline(TimeStamp aTimeStamp) { mSetIdleDeadlineCalled = true; }
+
+  void CheckExecutedMethods(const char* aKey, uint32_t aNumExecuted) {
+    uint32_t index;
+    for (index = 0; index < aNumExecuted; ++index) {
+      ASSERT_TRUE(mRunnableExecuted[index])
+      << aKey << ": Method" << index << " should've executed";
+    }
+
+    for (; index < ArrayLength(mRunnableExecuted); ++index) {
+      ASSERT_FALSE(mRunnableExecuted[index])
+      << aKey << ": Method" << index << " shouldn't have executed";
+    }
+  }
+
+  void Method0() {
+    CheckExecutedMethods("Method0", 0);
+    mRunnableExecuted[0] = true;
+    mSetIdleDeadlineCalled = false;
+  }
+
+  void Method1() {
+    CheckExecutedMethods("Method1", 1);
+    ASSERT_TRUE(mSetIdleDeadlineCalled);
+    mRunnableExecuted[1] = true;
+    mSetIdleDeadlineCalled = false;
+  }
+
+  void Method2() {
+    CheckExecutedMethods("Method2", 2);
+    ASSERT_TRUE(mSetIdleDeadlineCalled);
+    mRunnableExecuted[2] = true;
+    mSetIdleDeadlineCalled = false;
+    NS_DispatchToCurrentThread(
+        NewRunnableMethod("IdleObject::Method3", this, &IdleObject::Method3));
+  }
+
+  void Method3() {
+    CheckExecutedMethods("Method3", 3);
+
+    NS_NewTimerWithFuncCallback(getter_AddRefs(mTimer), Method4, this, 10,
+                                nsITimer::TYPE_ONE_SHOT, "IdleObject::Method3");
+    NS_DispatchToCurrentThreadQueue(
+        NewIdleRunnableMethodWithTimer("IdleObject::Method5", this,
+                                       &IdleObject::Method5),
+        50, EventQueuePriority::Idle);
+    NS_DispatchToCurrentThreadQueue(
+        NewRunnableMethod("IdleObject::Method6", this, &IdleObject::Method6),
+        100, EventQueuePriority::Idle);
+
+    PR_Sleep(PR_MillisecondsToInterval(200));
+    mRunnableExecuted[3] = true;
+    mSetIdleDeadlineCalled = false;
+  }
+
+  static void Method4(nsITimer* aTimer, void* aClosure) {
+    RefPtr<IdleObject> self = static_cast<IdleObject*>(aClosure);
+    self->CheckExecutedMethods("Method4", 4);
+    self->mRunnableExecuted[4] = true;
+    self->mSetIdleDeadlineCalled = false;
+  }
+
+  void Method5() {
+    CheckExecutedMethods("Method5", 5);
+    ASSERT_TRUE(mSetIdleDeadlineCalled);
+    mRunnableExecuted[5] = true;
+    mSetIdleDeadlineCalled = false;
+  }
+
+  void Method6() {
+    CheckExecutedMethods("Method6", 6);
+    mRunnableExecuted[6] = true;
+    mSetIdleDeadlineCalled = false;
+  }
+
+  void Method7() {
+    CheckExecutedMethods("Method7", 7);
+    ASSERT_TRUE(mSetIdleDeadlineCalled);
+    mRunnableExecuted[7] = true;
+    mSetIdleDeadlineCalled = false;
+  }
+
+ private:
+  nsCOMPtr<nsITimer> mTimer;
+  bool mRunnableExecuted[8];
+  bool mSetIdleDeadlineCalled;
+  ~IdleObject() = default;
+};
+
+// Disable test due to frequent failures
+#if 0
+// because test fails on multiple platforms
+TEST(ThreadUtils, IdleRunnableMethod)
+{
+  {
+    RefPtr<IdleObject> idle = new IdleObject();
+    RefPtr<IdleObjectWithoutSetDeadline> idleNoSetDeadline =
+        new IdleObjectWithoutSetDeadline();
+    RefPtr<IdleObjectInheritedSetDeadline> idleInheritedSetDeadline =
+        new IdleObjectInheritedSetDeadline();
+
+    NS_DispatchToCurrentThread(
+        NewRunnableMethod("IdleObject::Method0", idle, &IdleObject::Method0));
+    NS_DispatchToCurrentThreadQueue(
+        NewIdleRunnableMethod("IdleObject::Method1", idle,
+                              &IdleObject::Method1),
+        EventQueuePriority::Idle);
+    NS_DispatchToCurrentThreadQueue(
+        NewIdleRunnableMethodWithTimer("IdleObject::Method2", idle,
+                                       &IdleObject::Method2),
+        60000, EventQueuePriority::Idle);
+    NS_DispatchToCurrentThreadQueue(
+        NewIdleRunnableMethod("IdleObject::Method7", idle,
+                              &IdleObject::Method7),
+        EventQueuePriority::Idle);
+    NS_DispatchToCurrentThreadQueue(
+        NewIdleRunnableMethod<const char*, uint32_t>(
+            "IdleObject::CheckExecutedMethods", idle,
+            &IdleObject::CheckExecutedMethods, "final", 8),
+        EventQueuePriority::Idle);
+    NS_DispatchToCurrentThreadQueue(
+        NewIdleRunnableMethod("IdleObjectWithoutSetDeadline::Method",
+                              idleNoSetDeadline,
+                              &IdleObjectWithoutSetDeadline::Method),
+        EventQueuePriority::Idle);
+    NS_DispatchToCurrentThreadQueue(
+        NewIdleRunnableMethod("IdleObjectInheritedSetDeadline::Method",
+                              idleInheritedSetDeadline,
+                              &IdleObjectInheritedSetDeadline::Method),
+        EventQueuePriority::Idle);
+
+    NS_ProcessPendingEvents(nullptr);
+
+    ASSERT_TRUE(idleNoSetDeadline->mRunnableExecuted);
+    ASSERT_TRUE(idleInheritedSetDeadline->mRunnableExecuted);
+    ASSERT_TRUE(idleInheritedSetDeadline->mSetDeadlineCalled);
+  }
+}
+#endif
+
+TEST(ThreadUtils, IdleTaskRunner)
+{
+  using namespace mozilla;
+
+  // Repeating.
+  int cnt1 = 0;
+  RefPtr<IdleTaskRunner> runner1 = IdleTaskRunner::Create(
+      [&cnt1](TimeStamp) {
+        cnt1++;
+        return true;
+      },
+      "runner1", 0, TimeDuration::FromMilliseconds(10),
+      TimeDuration::FromMilliseconds(3), true, nullptr);
+
+  // Non-repeating but callback always return false so it's still repeating.
+  int cnt2 = 0;
+  RefPtr<IdleTaskRunner> runner2 = IdleTaskRunner::Create(
+      [&cnt2](TimeStamp) {
+        cnt2++;
+        return false;
+      },
+      "runner2", 0, TimeDuration::FromMilliseconds(10),
+      TimeDuration::FromMilliseconds(3), false, nullptr);
+
+  // Repeating until cnt3 >= 2 by returning 'true' in MayStopProcessing
+  // callback. The strategy is to stop repeating as early as possible so that we
+  // are more probable to catch the bug if it didn't stop as expected.
+  int cnt3 = 0;
+  RefPtr<IdleTaskRunner> runner3 = IdleTaskRunner::Create(
+      [&cnt3](TimeStamp) {
+        cnt3++;
+        return true;
+      },
+      "runner3", 0, TimeDuration::FromMilliseconds(10),
+      TimeDuration::FromMilliseconds(3), true, [&cnt3] { return cnt3 >= 2; });
+
+  // Non-repeating can callback return true so the callback will
+  // be only run once.
+  int cnt4 = 0;
+  RefPtr<IdleTaskRunner> runner4 = IdleTaskRunner::Create(
+      [&cnt4](TimeStamp) {
+        cnt4++;
+        return true;
+      },
+      "runner4", 0, TimeDuration::FromMilliseconds(10),
+      TimeDuration::FromMilliseconds(3), false, nullptr);
+
+  // Firstly we wait until the two repeating tasks reach their limits.
+  MOZ_ALWAYS_TRUE(
+      SpinEventLoopUntil("xpcom:TEST(ThreadUtils, IdleTaskRunner) cnt1"_ns,
+                         [&]() { return cnt1 >= 100; }));
+  MOZ_ALWAYS_TRUE(
+      SpinEventLoopUntil("xpcom:TEST(ThreadUtils, IdleTaskRunner) cnt2"_ns,
+                         [&]() { return cnt2 >= 100; }));
+
+  // At any point ==> 0 <= cnt3 <= 2 since MayStopProcessing() would return
+  // true when cnt3 >= 2.
+  MOZ_ALWAYS_TRUE(SpinEventLoopUntil(
+      "xpcom:TEST(ThreadUtils, IdleTaskRunner) cnt3"_ns, [&]() {
+        if (cnt3 > 2) {
+          EXPECT_TRUE(false) << "MaybeContinueProcess() doesn't work.";
+          return true;  // Stop on failure.
+        }
+        return cnt3 == 2;  // Stop finish if we have reached its max value.
+      }));
+
+  // At any point ==> 0 <= cnt4 <= 1 since this is a non-repeating
+  // idle runner.
+  MOZ_ALWAYS_TRUE(SpinEventLoopUntil(
+      "xpcom:TEST(ThreadUtils, IdleTaskRunner) cnt4"_ns, [&]() {
+        // At any point: 0 <= cnt4 <= 1
+        if (cnt4 > 1) {
+          EXPECT_TRUE(false) << "The 'mRepeating' flag doesn't work.";
+          return true;  // Stop on failure.
+        }
+        return cnt4 == 1;
+      }));
+
+  // The repeating timers require an explicit Cancel() call.
+  runner1->Cancel();
+  runner2->Cancel();
+}
+
+// {9e70a320-be02-11d1-8031-006008159b5a}
+#define NS_IFOO_IID                                  \
+  {                                                  \
+    0x9e70a320, 0xbe02, 0x11d1, {                    \
+      0x80, 0x31, 0x00, 0x60, 0x08, 0x15, 0x9b, 0x5a \
+    }                                                \
+  }
+
+TEST(ThreadUtils, TypeTraits)
+{
+  static_assert(!mozilla::IsRefcountedSmartPointer<int>::value,
+                "IsRefcountedSmartPointer<int> should be false");
+  static_assert(mozilla::IsRefcountedSmartPointer<RefPtr<int>>::value,
+                "IsRefcountedSmartPointer<RefPtr<...>> should be true");
+  static_assert(mozilla::IsRefcountedSmartPointer<const RefPtr<int>>::value,
+                "IsRefcountedSmartPointer<const RefPtr<...>> should be true");
+  static_assert(
+      mozilla::IsRefcountedSmartPointer<volatile RefPtr<int>>::value,
+      "IsRefcountedSmartPointer<volatile RefPtr<...>> should be true");
+  static_assert(
+      mozilla::IsRefcountedSmartPointer<const volatile RefPtr<int>>::value,
+      "IsRefcountedSmartPointer<const volatile RefPtr<...>> should be true");
+  static_assert(mozilla::IsRefcountedSmartPointer<nsCOMPtr<int>>::value,
+                "IsRefcountedSmartPointer<nsCOMPtr<...>> should be true");
+  static_assert(mozilla::IsRefcountedSmartPointer<const nsCOMPtr<int>>::value,
+                "IsRefcountedSmartPointer<const nsCOMPtr<...>> should be true");
+  static_assert(
+      mozilla::IsRefcountedSmartPointer<volatile nsCOMPtr<int>>::value,
+      "IsRefcountedSmartPointer<volatile nsCOMPtr<...>> should be true");
+  static_assert(
+      mozilla::IsRefcountedSmartPointer<const volatile nsCOMPtr<int>>::value,
+      "IsRefcountedSmartPointer<const volatile nsCOMPtr<...>> should be true");
+
+  static_assert(std::is_same_v<int, mozilla::RemoveSmartPointer<int>::Type>,
+                "RemoveSmartPointer<int>::Type should be int");
+  static_assert(std::is_same_v<int*, mozilla::RemoveSmartPointer<int*>::Type>,
+                "RemoveSmartPointer<int*>::Type should be int*");
+  static_assert(
+      std::is_same_v<UniquePtr<int>,
+                     mozilla::RemoveSmartPointer<UniquePtr<int>>::Type>,
+      "RemoveSmartPointer<UniquePtr<int>>::Type should be UniquePtr<int>");
+  static_assert(
+      std::is_same_v<int, mozilla::RemoveSmartPointer<RefPtr<int>>::Type>,
+      "RemoveSmartPointer<RefPtr<int>>::Type should be int");
+  static_assert(
+      std::is_same_v<int, mozilla::RemoveSmartPointer<const RefPtr<int>>::Type>,
+      "RemoveSmartPointer<const RefPtr<int>>::Type should be int");
+  static_assert(
+      std::is_same_v<int,
+                     mozilla::RemoveSmartPointer<volatile RefPtr<int>>::Type>,
+      "RemoveSmartPointer<volatile RefPtr<int>>::Type should be int");
+  static_assert(
+      std::is_same_v<
+          int, mozilla::RemoveSmartPointer<const volatile RefPtr<int>>::Type>,
+      "RemoveSmartPointer<const volatile RefPtr<int>>::Type should be int");
+  static_assert(
+      std::is_same_v<int, mozilla::RemoveSmartPointer<nsCOMPtr<int>>::Type>,
+      "RemoveSmartPointer<nsCOMPtr<int>>::Type should be int");
+  static_assert(
+      std::is_same_v<int,
+                     mozilla::RemoveSmartPointer<const nsCOMPtr<int>>::Type>,
+      "RemoveSmartPointer<const nsCOMPtr<int>>::Type should be int");
+  static_assert(
+      std::is_same_v<int,
+                     mozilla::RemoveSmartPointer<volatile nsCOMPtr<int>>::Type>,
+      "RemoveSmartPointer<volatile nsCOMPtr<int>>::Type should be int");
+  static_assert(
+      std::is_same_v<
+          int, mozilla::RemoveSmartPointer<const volatile nsCOMPtr<int>>::Type>,
+      "RemoveSmartPointer<const volatile nsCOMPtr<int>>::Type should be int");
+
+  static_assert(
+      std::is_same_v<int, mozilla::RemoveRawOrSmartPointer<int>::Type>,
+      "RemoveRawOrSmartPointer<int>::Type should be int");
+  static_assert(
+      std::is_same_v<UniquePtr<int>,
+                     mozilla::RemoveRawOrSmartPointer<UniquePtr<int>>::Type>,
+      "RemoveRawOrSmartPointer<UniquePtr<int>>::Type should be UniquePtr<int>");
+  static_assert(
+      std::is_same_v<int, mozilla::RemoveRawOrSmartPointer<int*>::Type>,
+      "RemoveRawOrSmartPointer<int*>::Type should be int");
+  static_assert(
+      std::is_same_v<const int,
+                     mozilla::RemoveRawOrSmartPointer<const int*>::Type>,
+      "RemoveRawOrSmartPointer<const int*>::Type should be const int");
+  static_assert(
+      std::is_same_v<volatile int,
+                     mozilla::RemoveRawOrSmartPointer<volatile int*>::Type>,
+      "RemoveRawOrSmartPointer<volatile int*>::Type should be volatile int");
+  static_assert(
+      std::is_same_v<const volatile int, mozilla::RemoveRawOrSmartPointer<
+                                             const volatile int*>::Type>,
+      "RemoveRawOrSmartPointer<const volatile int*>::Type should be const "
+      "volatile int");
+  static_assert(
+      std::is_same_v<int, mozilla::RemoveRawOrSmartPointer<RefPtr<int>>::Type>,
+      "RemoveRawOrSmartPointer<RefPtr<int>>::Type should be int");
+  static_assert(
+      std::is_same_v<int,
+                     mozilla::RemoveRawOrSmartPointer<const RefPtr<int>>::Type>,
+      "RemoveRawOrSmartPointer<const RefPtr<int>>::Type should be int");
+  static_assert(
+      std::is_same_v<
+          int, mozilla::RemoveRawOrSmartPointer<volatile RefPtr<int>>::Type>,
+      "RemoveRawOrSmartPointer<volatile RefPtr<int>>::Type should be int");
+  static_assert(
+      std::is_same_v<int, mozilla::RemoveRawOrSmartPointer<
+                              const volatile RefPtr<int>>::Type>,
+      "RemoveRawOrSmartPointer<const volatile RefPtr<int>>::Type should be "
+      "int");
+  static_assert(
+      std::is_same_v<int,
+                     mozilla::RemoveRawOrSmartPointer<nsCOMPtr<int>>::Type>,
+      "RemoveRawOrSmartPointer<nsCOMPtr<int>>::Type should be int");
+  static_assert(
+      std::is_same_v<
+          int, mozilla::RemoveRawOrSmartPointer<const nsCOMPtr<int>>::Type>,
+      "RemoveRawOrSmartPointer<const nsCOMPtr<int>>::Type should be int");
+  static_assert(
+      std::is_same_v<
+          int, mozilla::RemoveRawOrSmartPointer<volatile nsCOMPtr<int>>::Type>,
+      "RemoveRawOrSmartPointer<volatile nsCOMPtr<int>>::Type should be int");
+  static_assert(
+      std::is_same_v<int, mozilla::RemoveRawOrSmartPointer<
+                              const volatile nsCOMPtr<int>>::Type>,
+      "RemoveRawOrSmartPointer<const volatile nsCOMPtr<int>>::Type should be "
+      "int");
+}
+
+namespace TestThreadUtils {
+
+static bool gDebug = false;
+static int gAlive, gZombies;
+static int gAllConstructions, gConstructions, gCopyConstructions,
+    gMoveConstructions, gDestructions, gAssignments, gMoves;
+struct Spy {
+  static void ClearActions() {
+    gAllConstructions = gConstructions = gCopyConstructions =
+        gMoveConstructions = gDestructions = gAssignments = gMoves = 0;
+  }
+  static void ClearAll() {
+    ClearActions();
+    gAlive = 0;
+  }
+
+  explicit Spy(int aID) : mID(aID) {
+    ++gAlive;
+    ++gAllConstructions;
+    ++gConstructions;
+    if (gDebug) {
+      printf("Spy[%d@%p]()\n", mID, this);
+    }
+  }
+  Spy(const Spy& o) : mID(o.mID) {
+    ++gAlive;
+    ++gAllConstructions;
+    ++gCopyConstructions;
+    if (gDebug) {
+      printf("Spy[%d@%p](&[%d@%p])\n", mID, this, o.mID, &o);
+    }
+  }
+  Spy(Spy&& o) : mID(o.mID) {
+    o.mID = -o.mID;
+    ++gZombies;
+    ++gAllConstructions;
+    ++gMoveConstructions;
+    if (gDebug) {
+      printf("Spy[%d@%p](&&[%d->%d@%p])\n", mID, this, -o.mID, o.mID, &o);
+    }
+  }
+  ~Spy() {
+    if (mID >= 0) {
+      --gAlive;
+    } else {
+      --gZombies;
+    }
+    ++gDestructions;
+    if (gDebug) {
+      printf("~Spy[%d@%p]()\n", mID, this);
+    }
+    mID = 0;
+  }
+  Spy& operator=(const Spy& o) {
+    ++gAssignments;
+    if (gDebug) {
+      printf("Spy[%d->%d@%p] = &[%d@%p]\n", mID, o.mID, this, o.mID, &o);
+    }
+    mID = o.mID;
+    return *this;
+  };
+  Spy& operator=(Spy&& o) {
+    --gAlive;
+    ++gZombies;
+    ++gMoves;
+    if (gDebug) {
+      printf("Spy[%d->%d@%p] = &&[%d->%d@%p]\n", mID, o.mID, this, o.mID,
+             -o.mID, &o);
+    }
+    mID = o.mID;
+    o.mID = -o.mID;
+    return *this;
+  };
+
+  int mID;  // ID given at construction, or negation if was moved from; 0 when
+            // destroyed.
+};
+
+struct ISpyWithISupports : public nsISupports {
+  NS_DECLARE_STATIC_IID_ACCESSOR(NS_IFOO_IID)
+  NS_IMETHOD_(nsrefcnt) RefCnt() = 0;
+  NS_IMETHOD_(int32_t) ID() = 0;
+};
+NS_DEFINE_STATIC_IID_ACCESSOR(ISpyWithISupports, NS_IFOO_IID)
+struct SpyWithISupports : public ISpyWithISupports, public Spy {
+ private:
+  virtual ~SpyWithISupports() = default;
+
+ public:
+  explicit SpyWithISupports(int aID) : Spy(aID){};
+  NS_DECL_ISUPPORTS
+  NS_IMETHOD_(nsrefcnt) RefCnt() override { return mRefCnt; }
+  NS_IMETHOD_(int32_t) ID() override { return mID; }
+};
+NS_IMPL_ISUPPORTS(SpyWithISupports, ISpyWithISupports)
+
+class IThreadUtilsObject : public nsISupports {
+ public:
+  NS_DECLARE_STATIC_IID_ACCESSOR(NS_IFOO_IID)
+
+  NS_IMETHOD_(nsrefcnt) RefCnt() = 0;
+  NS_IMETHOD_(int32_t) ID() = 0;
+};
+
+NS_DEFINE_STATIC_IID_ACCESSOR(IThreadUtilsObject, NS_IFOO_IID)
+
+struct ThreadUtilsObjectNonRefCountedBase {
+  virtual void MethodFromNonRefCountedBase() {}
+};
+
+struct ThreadUtilsObject : public IThreadUtilsObject,
+                           public ThreadUtilsObjectNonRefCountedBase {
+  // nsISupports implementation
+  NS_DECL_ISUPPORTS
+
+  // IThreadUtilsObject implementation
+  NS_IMETHOD_(nsrefcnt) RefCnt() override { return mRefCnt; }
+  NS_IMETHOD_(int32_t) ID() override { return 0; }
+
+  int mCount;  // Number of calls + arguments processed.
+  int mA0, mA1, mA2, mA3;
+  Spy mSpy;
+  const Spy* mSpyPtr;
+  ThreadUtilsObject()
+      : mCount(0), mA0(0), mA1(0), mA2(0), mA3(0), mSpy(1), mSpyPtr(nullptr) {}
+
+ private:
+  virtual ~ThreadUtilsObject() = default;
+
+ public:
+  void Test0() { mCount += 1; }
+  void Test1i(int a0) {
+    mCount += 2;
+    mA0 = a0;
+  }
+  void Test2i(int a0, int a1) {
+    mCount += 3;
+    mA0 = a0;
+    mA1 = a1;
+  }
+  void Test3i(int a0, int a1, int a2) {
+    mCount += 4;
+    mA0 = a0;
+    mA1 = a1;
+    mA2 = a2;
+  }
+  void Test4i(int a0, int a1, int a2, int a3) {
+    mCount += 5;
+    mA0 = a0;
+    mA1 = a1;
+    mA2 = a2;
+    mA3 = a3;
+  }
+  void Test1pi(int* ap) {
+    mCount += 2;
+    mA0 = ap ? *ap : -1;
+  }
+  void Test1pci(const int* ap) {
+    mCount += 2;
+    mA0 = ap ? *ap : -1;
+  }
+  void Test1ri(int& ar) {
+    mCount += 2;
+    mA0 = ar;
+  }
+  void Test1rri(int&& arr) {
+    mCount += 2;
+    mA0 = arr;
+  }
+  void Test1upi(mozilla::UniquePtr<int> aup) {
+    mCount += 2;
+    mA0 = aup ? *aup : -1;
+  }
+  void Test1rupi(mozilla::UniquePtr<int>& aup) {
+    mCount += 2;
+    mA0 = aup ? *aup : -1;
+  }
+  void Test1rrupi(mozilla::UniquePtr<int>&& aup) {
+    mCount += 2;
+    mA0 = aup ? *aup : -1;
+  }
+
+  void Test1s(Spy) { mCount += 2; }
+  void Test1ps(Spy*) { mCount += 2; }
+  void Test1rs(Spy&) { mCount += 2; }
+  void Test1rrs(Spy&&) { mCount += 2; }
+  void Test1ups(mozilla::UniquePtr<Spy>) { mCount += 2; }
+  void Test1rups(mozilla::UniquePtr<Spy>&) { mCount += 2; }
+  void Test1rrups(mozilla::UniquePtr<Spy>&&) { mCount += 2; }
+
+  // Possible parameter passing styles:
+  void TestByValue(Spy s) {
+    if (gDebug) {
+      printf("TestByValue(Spy[%d@%p])\n", s.mID, &s);
+    }
+    mSpy = s;
+  };
+  void TestByConstLRef(const Spy& s) {
+    if (gDebug) {
+      printf("TestByConstLRef(Spy[%d@%p]&)\n", s.mID, &s);
+    }
+    mSpy = s;
+  };
+  void TestByRRef(Spy&& s) {
+    if (gDebug) {
+      printf("TestByRRef(Spy[%d@%p]&&)\n", s.mID, &s);
+    }
+    mSpy = std::move(s);
+  };
+  void TestByLRef(Spy& s) {
+    if (gDebug) {
+      printf("TestByLRef(Spy[%d@%p]&)\n", s.mID, &s);
+    }
+    mSpy = s;
+    mSpyPtr = &s;
+  };
+  void TestByPointer(Spy* p) {
+    if (p) {
+      if (gDebug) {
+        printf("TestByPointer(&Spy[%d@%p])\n", p->mID, p);
+      }
+      mSpy = *p;
+    } else {
+      if (gDebug) {
+        printf("TestByPointer(nullptr)\n");
+      }
+    }
+    mSpyPtr = p;
+  };
+  void TestByPointerToConst(const Spy* p) {
+    if (p) {
+      if (gDebug) {
+        printf("TestByPointerToConst(&Spy[%d@%p])\n", p->mID, p);
+      }
+      mSpy = *p;
+    } else {
+      if (gDebug) {
+        printf("TestByPointerToConst(nullptr)\n");
+      }
+    }
+    mSpyPtr = p;
+  };
+};
+
+NS_IMPL_ISUPPORTS(ThreadUtilsObject, IThreadUtilsObject)
+
+class ThreadUtilsRefCountedFinal final {
+ public:
+  ThreadUtilsRefCountedFinal() : m_refCount(0) {}
+  ~ThreadUtilsRefCountedFinal() = default;
+  // 'AddRef' and 'Release' methods with different return types, to verify
+  // that the return type doesn't influence storage selection.
+  long AddRef(void) { return ++m_refCount; }
+  void Release(void) { --m_refCount; }
+
+ private:
+  long m_refCount;
+};
+
+class ThreadUtilsRefCountedBase {
+ public:
+  ThreadUtilsRefCountedBase() : m_refCount(0) {}
+  virtual ~ThreadUtilsRefCountedBase() = default;
+  // 'AddRef' and 'Release' methods with different return types, to verify
+  // that the return type doesn't influence storage selection.
+  virtual void AddRef(void) { ++m_refCount; }
+  virtual MozExternalRefCountType Release(void) { return --m_refCount; }
+
+ private:
+  MozExternalRefCountType m_refCount;
+};
+
+class ThreadUtilsRefCountedDerived : public ThreadUtilsRefCountedBase {};
+
+class ThreadUtilsNonRefCounted {};
+
+}  // namespace TestThreadUtils
+
+TEST(ThreadUtils, main)
+{
+  using namespace TestThreadUtils;
+
+  static_assert(!IsParameterStorageClass<int>::value,
+                "'int' should not be recognized as Storage Class");
+  static_assert(
+      IsParameterStorageClass<StoreCopyPassByValue<int>>::value,
+      "StoreCopyPassByValue<int> should be recognized as Storage Class");
+  static_assert(
+      IsParameterStorageClass<StoreCopyPassByConstLRef<int>>::value,
+      "StoreCopyPassByConstLRef<int> should be recognized as Storage Class");
+  static_assert(
+      IsParameterStorageClass<StoreCopyPassByLRef<int>>::value,
+      "StoreCopyPassByLRef<int> should be recognized as Storage Class");
+  static_assert(
+      IsParameterStorageClass<StoreCopyPassByRRef<int>>::value,
+      "StoreCopyPassByRRef<int> should be recognized as Storage Class");
+  static_assert(
+      IsParameterStorageClass<StoreRefPassByLRef<int>>::value,
+      "StoreRefPassByLRef<int> should be recognized as Storage Class");
+  static_assert(
+      IsParameterStorageClass<StoreConstRefPassByConstLRef<int>>::value,
+      "StoreConstRefPassByConstLRef<int> should be recognized as Storage "
+      "Class");
+  static_assert(
+      IsParameterStorageClass<StoreRefPtrPassByPtr<int>>::value,
+      "StoreRefPtrPassByPtr<int> should be recognized as Storage Class");
+  static_assert(IsParameterStorageClass<StorePtrPassByPtr<int>>::value,
+                "StorePtrPassByPtr<int> should be recognized as Storage Class");
+  static_assert(
+      IsParameterStorageClass<StoreConstPtrPassByConstPtr<int>>::value,
+      "StoreConstPtrPassByConstPtr<int> should be recognized as Storage Class");
+  static_assert(
+      IsParameterStorageClass<StoreCopyPassByConstPtr<int>>::value,
+      "StoreCopyPassByConstPtr<int> should be recognized as Storage Class");
+  static_assert(
+      IsParameterStorageClass<StoreCopyPassByPtr<int>>::value,
+      "StoreCopyPassByPtr<int> should be recognized as Storage Class");
+
+  RefPtr<ThreadUtilsObject> rpt(new ThreadUtilsObject);
+  int count = 0;
+
+  // Test legacy functions.
+
+  nsCOMPtr<nsIRunnable> r1 =
+      NewRunnableMethod("TestThreadUtils::ThreadUtilsObject::Test0", rpt,
+                        &ThreadUtilsObject::Test0);
+  r1->Run();
+  EXPECT_EQ(count += 1, rpt->mCount);
+
+  r1 = NewRunnableMethod<int>("TestThreadUtils::ThreadUtilsObject::Test1i", rpt,
+                              &ThreadUtilsObject::Test1i, 11);
+  r1->Run();
+  EXPECT_EQ(count += 2, rpt->mCount);
+  EXPECT_EQ(11, rpt->mA0);
+
+  // Test calling a method from a non-ref-counted base.
+
+  r1 = NewRunnableMethod(
+      "TestThreadUtils::ThreadUtilsObjectNonRefCountedBase::"
+      "MethodFromNonRefCountedBase",
+      rpt, &ThreadUtilsObject::MethodFromNonRefCountedBase);
+  r1->Run();
+  EXPECT_EQ(count, rpt->mCount);
+
+  // Test variadic function with simple POD arguments.
+
+  r1 = NewRunnableMethod("TestThreadUtils::ThreadUtilsObject::Test0", rpt,
+                         &ThreadUtilsObject::Test0);
+  r1->Run();
+  EXPECT_EQ(count += 1, rpt->mCount);
+
+  static_assert(std::is_same_v<::detail::ParameterStorage<int>::Type,
+                               StoreCopyPassByConstLRef<int>>,
+                "detail::ParameterStorage<int>::Type should be "
+                "StoreCopyPassByConstLRef<int>");
+  static_assert(std::is_same_v<
+                    ::detail::ParameterStorage<StoreCopyPassByValue<int>>::Type,
+                    StoreCopyPassByValue<int>>,
+                "detail::ParameterStorage<StoreCopyPassByValue<int>>::Type "
+                "should be StoreCopyPassByValue<int>");
+
+  r1 = NewRunnableMethod<int>("TestThreadUtils::ThreadUtilsObject::Test1i", rpt,
+                              &ThreadUtilsObject::Test1i, 12);
+  r1->Run();
+  EXPECT_EQ(count += 2, rpt->mCount);
+  EXPECT_EQ(12, rpt->mA0);
+
+  r1 = NewRunnableMethod<int, int>("TestThreadUtils::ThreadUtilsObject::Test2i",
+                                   rpt, &ThreadUtilsObject::Test2i, 21, 22);
+  r1->Run();
+  EXPECT_EQ(count += 3, rpt->mCount);
+  EXPECT_EQ(21, rpt->mA0);
+  EXPECT_EQ(22, rpt->mA1);
+
+  r1 = NewRunnableMethod<int, int, int>(
+      "TestThreadUtils::ThreadUtilsObject::Test3i", rpt,
+      &ThreadUtilsObject::Test3i, 31, 32, 33);
+  r1->Run();
+  EXPECT_EQ(count += 4, rpt->mCount);
+  EXPECT_EQ(31, rpt->mA0);
+  EXPECT_EQ(32, rpt->mA1);
+  EXPECT_EQ(33, rpt->mA2);
+
+  r1 = NewRunnableMethod<int, int, int, int>(
+      "TestThreadUtils::ThreadUtilsObject::Test4i", rpt,
+      &ThreadUtilsObject::Test4i, 41, 42, 43, 44);
+  r1->Run();
+  EXPECT_EQ(count += 5, rpt->mCount);
+  EXPECT_EQ(41, rpt->mA0);
+  EXPECT_EQ(42, rpt->mA1);
+  EXPECT_EQ(43, rpt->mA2);
+  EXPECT_EQ(44, rpt->mA3);
+
+  // More interesting types of arguments.
+
+  // Passing a short to make sure forwarding works with an inexact type match.
+  short int si = 11;
+  r1 = NewRunnableMethod<int>("TestThreadUtils::ThreadUtilsObject::Test1i", rpt,
+                              &ThreadUtilsObject::Test1i, si);
+  r1->Run();
+  EXPECT_EQ(count += 2, rpt->mCount);
+  EXPECT_EQ(si, rpt->mA0);
+
+  // Raw pointer, possible cv-qualified.
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<int*>::Type,
+                     StorePtrPassByPtr<int>>,
+      "detail::ParameterStorage<int*>::Type should be StorePtrPassByPtr<int>");
+  static_assert(std::is_same_v<::detail::ParameterStorage<int* const>::Type,
+                               StorePtrPassByPtr<int>>,
+                "detail::ParameterStorage<int* const>::Type should be "
+                "StorePtrPassByPtr<int>");
+  static_assert(std::is_same_v<::detail::ParameterStorage<int* volatile>::Type,
+                               StorePtrPassByPtr<int>>,
+                "detail::ParameterStorage<int* volatile>::Type should be "
+                "StorePtrPassByPtr<int>");
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<int* const volatile>::Type,
+                     StorePtrPassByPtr<int>>,
+      "detail::ParameterStorage<int* const volatile>::Type should be "
+      "StorePtrPassByPtr<int>");
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<int*>::Type::stored_type, int*>,
+      "detail::ParameterStorage<int*>::Type::stored_type should be int*");
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<int*>::Type::passed_type, int*>,
+      "detail::ParameterStorage<int*>::Type::passed_type should be int*");
+  {
+    int i = 12;
+    r1 = NewRunnableMethod<int*>("TestThreadUtils::ThreadUtilsObject::Test1pi",
+                                 rpt, &ThreadUtilsObject::Test1pi, &i);
+    r1->Run();
+    EXPECT_EQ(count += 2, rpt->mCount);
+    EXPECT_EQ(i, rpt->mA0);
+  }
+
+  // Raw pointer to const.
+  static_assert(std::is_same_v<::detail::ParameterStorage<const int*>::Type,
+                               StoreConstPtrPassByConstPtr<int>>,
+                "detail::ParameterStorage<const int*>::Type should be "
+                "StoreConstPtrPassByConstPtr<int>");
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<const int* const>::Type,
+                     StoreConstPtrPassByConstPtr<int>>,
+      "detail::ParameterStorage<const int* const>::Type should be "
+      "StoreConstPtrPassByConstPtr<int>");
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<const int* volatile>::Type,
+                     StoreConstPtrPassByConstPtr<int>>,
+      "detail::ParameterStorage<const int* volatile>::Type should be "
+      "StoreConstPtrPassByConstPtr<int>");
+  static_assert(std::is_same_v<
+                    ::detail::ParameterStorage<const int* const volatile>::Type,
+                    StoreConstPtrPassByConstPtr<int>>,
+                "detail::ParameterStorage<const int* const volatile>::Type "
+                "should be StoreConstPtrPassByConstPtr<int>");
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<const int*>::Type::stored_type,
+                     const int*>,
+      "detail::ParameterStorage<const int*>::Type::stored_type should be const "
+      "int*");
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<const int*>::Type::passed_type,
+                     const int*>,
+      "detail::ParameterStorage<const int*>::Type::passed_type should be const "
+      "int*");
+  {
+    int i = 1201;
+    r1 = NewRunnableMethod<const int*>(
+        "TestThreadUtils::ThreadUtilsObject::Test1pci", rpt,
+        &ThreadUtilsObject::Test1pci, &i);
+    r1->Run();
+    EXPECT_EQ(count += 2, rpt->mCount);
+    EXPECT_EQ(i, rpt->mA0);
+  }
+
+  // Raw pointer to copy.
+  static_assert(std::is_same_v<StoreCopyPassByPtr<int>::stored_type, int>,
+                "StoreCopyPassByPtr<int>::stored_type should be int");
+  static_assert(std::is_same_v<StoreCopyPassByPtr<int>::passed_type, int*>,
+                "StoreCopyPassByPtr<int>::passed_type should be int*");
+  {
+    int i = 1202;
+    r1 = NewRunnableMethod<StoreCopyPassByPtr<int>>(
+        "TestThreadUtils::ThreadUtilsObject::Test1pi", rpt,
+        &ThreadUtilsObject::Test1pi, i);
+    r1->Run();
+    EXPECT_EQ(count += 2, rpt->mCount);
+    EXPECT_EQ(i, rpt->mA0);
+  }
+
+  // Raw pointer to const copy.
+  static_assert(std::is_same_v<StoreCopyPassByConstPtr<int>::stored_type, int>,
+                "StoreCopyPassByConstPtr<int>::stored_type should be int");
+  static_assert(
+      std::is_same_v<StoreCopyPassByConstPtr<int>::passed_type, const int*>,
+      "StoreCopyPassByConstPtr<int>::passed_type should be const int*");
+  {
+    int i = 1203;
+    r1 = NewRunnableMethod<StoreCopyPassByConstPtr<int>>(
+        "TestThreadUtils::ThreadUtilsObject::Test1pci", rpt,
+        &ThreadUtilsObject::Test1pci, i);
+    r1->Run();
+    EXPECT_EQ(count += 2, rpt->mCount);
+    EXPECT_EQ(i, rpt->mA0);
+  }
+
+  // nsRefPtr to pointer.
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<
+                         StoreRefPtrPassByPtr<SpyWithISupports>>::Type,
+                     StoreRefPtrPassByPtr<SpyWithISupports>>,
+      "ParameterStorage<StoreRefPtrPassByPtr<SpyWithISupports>>::Type should "
+      "be StoreRefPtrPassByPtr<SpyWithISupports>");
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<SpyWithISupports*>::Type,
+                     StoreRefPtrPassByPtr<SpyWithISupports>>,
+      "ParameterStorage<SpyWithISupports*>::Type should be "
+      "StoreRefPtrPassByPtr<SpyWithISupports>");
+  static_assert(
+      std::is_same_v<StoreRefPtrPassByPtr<SpyWithISupports>::stored_type,
+                     RefPtr<SpyWithISupports>>,
+      "StoreRefPtrPassByPtr<SpyWithISupports>::stored_type should be "
+      "RefPtr<SpyWithISupports>");
+  static_assert(
+      std::is_same_v<StoreRefPtrPassByPtr<SpyWithISupports>::passed_type,
+                     SpyWithISupports*>,
+      "StoreRefPtrPassByPtr<SpyWithISupports>::passed_type should be "
+      "SpyWithISupports*");
+  // (more nsRefPtr tests below)
+
+  // nsRefPtr for ref-countable classes that do not derive from ISupports.
+  static_assert(::detail::HasRefCountMethods<ThreadUtilsRefCountedFinal>::value,
+                "ThreadUtilsRefCountedFinal has AddRef() and Release()");
+  static_assert(
+      std::is_same_v<
+          ::detail::ParameterStorage<ThreadUtilsRefCountedFinal*>::Type,
+          StoreRefPtrPassByPtr<ThreadUtilsRefCountedFinal>>,
+      "ParameterStorage<ThreadUtilsRefCountedFinal*>::Type should be "
+      "StoreRefPtrPassByPtr<ThreadUtilsRefCountedFinal>");
+  static_assert(::detail::HasRefCountMethods<ThreadUtilsRefCountedBase>::value,
+                "ThreadUtilsRefCountedBase has AddRef() and Release()");
+  static_assert(
+      std::is_same_v<
+          ::detail::ParameterStorage<ThreadUtilsRefCountedBase*>::Type,
+          StoreRefPtrPassByPtr<ThreadUtilsRefCountedBase>>,
+      "ParameterStorage<ThreadUtilsRefCountedBase*>::Type should be "
+      "StoreRefPtrPassByPtr<ThreadUtilsRefCountedBase>");
+  static_assert(
+      ::detail::HasRefCountMethods<ThreadUtilsRefCountedDerived>::value,
+      "ThreadUtilsRefCountedDerived has AddRef() and Release()");
+  static_assert(
+      std::is_same_v<
+          ::detail::ParameterStorage<ThreadUtilsRefCountedDerived*>::Type,
+          StoreRefPtrPassByPtr<ThreadUtilsRefCountedDerived>>,
+      "ParameterStorage<ThreadUtilsRefCountedDerived*>::Type should be "
+      "StoreRefPtrPassByPtr<ThreadUtilsRefCountedDerived>");
+
+  static_assert(!::detail::HasRefCountMethods<ThreadUtilsNonRefCounted>::value,
+                "ThreadUtilsNonRefCounted doesn't have AddRef() and Release()");
+  static_assert(!std::is_same_v<
+                    ::detail::ParameterStorage<ThreadUtilsNonRefCounted*>::Type,
+                    StoreRefPtrPassByPtr<ThreadUtilsNonRefCounted>>,
+                "ParameterStorage<ThreadUtilsNonRefCounted*>::Type should NOT "
+                "be StoreRefPtrPassByPtr<ThreadUtilsNonRefCounted>");
+
+  // Lvalue reference.
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<int&>::Type,
+                     StoreRefPassByLRef<int>>,
+      "ParameterStorage<int&>::Type should be StoreRefPassByLRef<int>");
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<int&>::Type::stored_type,
+                     StoreRefPassByLRef<int>::stored_type>,
+      "ParameterStorage<int&>::Type::stored_type should be "
+      "StoreRefPassByLRef<int>::stored_type");
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<int&>::Type::stored_type, int&>,
+      "ParameterStorage<int&>::Type::stored_type should be int&");
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<int&>::Type::passed_type, int&>,
+      "ParameterStorage<int&>::Type::passed_type should be int&");
+  {
+    int i = 13;
+    r1 = NewRunnableMethod<int&>("TestThreadUtils::ThreadUtilsObject::Test1ri",
+                                 rpt, &ThreadUtilsObject::Test1ri, i);
+    r1->Run();
+    EXPECT_EQ(count += 2, rpt->mCount);
+    EXPECT_EQ(i, rpt->mA0);
+  }
+
+  // Rvalue reference -- Actually storing a copy and then moving it.
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<int&&>::Type,
+                     StoreCopyPassByRRef<int>>,
+      "ParameterStorage<int&&>::Type should be StoreCopyPassByRRef<int>");
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<int&&>::Type::stored_type,
+                     StoreCopyPassByRRef<int>::stored_type>,
+      "ParameterStorage<int&&>::Type::stored_type should be "
+      "StoreCopyPassByRRef<int>::stored_type");
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<int&&>::Type::stored_type, int>,
+      "ParameterStorage<int&&>::Type::stored_type should be int");
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<int&&>::Type::passed_type,
+                     int&&>,
+      "ParameterStorage<int&&>::Type::passed_type should be int&&");
+  {
+    int i = 14;
+    r1 = NewRunnableMethod<int&&>(
+        "TestThreadUtils::ThreadUtilsObject::Test1rri", rpt,
+        &ThreadUtilsObject::Test1rri, std::move(i));
+  }
+  r1->Run();
+  EXPECT_EQ(count += 2, rpt->mCount);
+  EXPECT_EQ(14, rpt->mA0);
+
+  // Null unique pointer, by semi-implicit store&move with "T&&" syntax.
+  static_assert(std::is_same_v<
+                    ::detail::ParameterStorage<mozilla::UniquePtr<int>&&>::Type,
+                    StoreCopyPassByRRef<mozilla::UniquePtr<int>>>,
+                "ParameterStorage<UniquePtr<int>&&>::Type should be "
+                "StoreCopyPassByRRef<UniquePtr<int>>");
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<
+                         mozilla::UniquePtr<int>&&>::Type::stored_type,
+                     StoreCopyPassByRRef<mozilla::UniquePtr<int>>::stored_type>,
+      "ParameterStorage<UniquePtr<int>&&>::Type::stored_type should be "
+      "StoreCopyPassByRRef<UniquePtr<int>>::stored_type");
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<
+                         mozilla::UniquePtr<int>&&>::Type::stored_type,
+                     mozilla::UniquePtr<int>>,
+      "ParameterStorage<UniquePtr<int>&&>::Type::stored_type should be "
+      "UniquePtr<int>");
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<
+                         mozilla::UniquePtr<int>&&>::Type::passed_type,
+                     mozilla::UniquePtr<int>&&>,
+      "ParameterStorage<UniquePtr<int>&&>::Type::passed_type should be "
+      "UniquePtr<int>&&");
+  {
+    mozilla::UniquePtr<int> upi;
+    r1 = NewRunnableMethod<mozilla::UniquePtr<int>&&>(
+        "TestThreadUtils::ThreadUtilsObject::Test1upi", rpt,
+        &ThreadUtilsObject::Test1upi, std::move(upi));
+  }
+  r1->Run();
+  EXPECT_EQ(count += 2, rpt->mCount);
+  EXPECT_EQ(-1, rpt->mA0);
+  rpt->mA0 = 0;
+
+  // Null unique pointer, by explicit store&move with "StoreCopyPassByRRef<T>"
+  // syntax.
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<StoreCopyPassByRRef<
+                         mozilla::UniquePtr<int>>>::Type::stored_type,
+                     StoreCopyPassByRRef<mozilla::UniquePtr<int>>::stored_type>,
+      "ParameterStorage<StoreCopyPassByRRef<UniquePtr<int>>>::Type::stored_"
+      "type should be StoreCopyPassByRRef<UniquePtr<int>>::stored_type");
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<StoreCopyPassByRRef<
+                         mozilla::UniquePtr<int>>>::Type::stored_type,
+                     StoreCopyPassByRRef<mozilla::UniquePtr<int>>::stored_type>,
+      "ParameterStorage<StoreCopyPassByRRef<UniquePtr<int>>>::Type::stored_"
+      "type should be StoreCopyPassByRRef<UniquePtr<int>>::stored_type");
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<StoreCopyPassByRRef<
+                         mozilla::UniquePtr<int>>>::Type::stored_type,
+                     mozilla::UniquePtr<int>>,
+      "ParameterStorage<StoreCopyPassByRRef<UniquePtr<int>>>::Type::stored_"
+      "type should be UniquePtr<int>");
+  static_assert(
+      std::is_same_v<::detail::ParameterStorage<StoreCopyPassByRRef<
+                         mozilla::UniquePtr<int>>>::Type::passed_type,
+                     mozilla::UniquePtr<int>&&>,
+      "ParameterStorage<StoreCopyPassByRRef<UniquePtr<int>>>::Type::passed_"
+      "type should be UniquePtr<int>&&");
+  {
+    mozilla::UniquePtr<int> upi;
+    r1 = NewRunnableMethod<StoreCopyPassByRRef<mozilla::UniquePtr<int>>>(
+        "TestThreadUtils::ThreadUtilsObject::Test1upi", rpt,
+        &ThreadUtilsObject::Test1upi, std::move(upi));
+  }
+  r1->Run();
+  EXPECT_EQ(count += 2, rpt->mCount);
+  EXPECT_EQ(-1, rpt->mA0);
+
+  // Unique pointer as xvalue.
+  {
+    mozilla::UniquePtr<int> upi = mozilla::MakeUnique<int>(1);
+    r1 = NewRunnableMethod<mozilla::UniquePtr<int>&&>(
+        "TestThreadUtils::ThreadUtilsObject::Test1upi", rpt,
+        &ThreadUtilsObject::Test1upi, std::move(upi));
+  }
+  r1->Run();
+  EXPECT_EQ(count += 2, rpt->mCount);
+  EXPECT_EQ(1, rpt->mA0);
+
+  {
+    mozilla::UniquePtr<int> upi = mozilla::MakeUnique<int>(1);
+    r1 = NewRunnableMethod<StoreCopyPassByRRef<mozilla::UniquePtr<int>>>(
+        "TestThreadUtils::ThreadUtilsObject::Test1upi", rpt,
+        &ThreadUtilsObject::Test1upi, std::move(upi));
+  }
+  r1->Run();
+  EXPECT_EQ(count += 2, rpt->mCount);
+  EXPECT_EQ(1, rpt->mA0);
+
+  // Unique pointer as prvalue.
+  r1 = NewRunnableMethod<mozilla::UniquePtr<int>&&>(
+      "TestThreadUtils::ThreadUtilsObject::Test1upi", rpt,
+      &ThreadUtilsObject::Test1upi, mozilla::MakeUnique<int>(2));
+  r1->Run();
+  EXPECT_EQ(count += 2, rpt->mCount);
+  EXPECT_EQ(2, rpt->mA0);
+
+  // Unique pointer as lvalue to lref.
+  {
+    mozilla::UniquePtr<int> upi;
+    r1 = NewRunnableMethod<mozilla::UniquePtr<int>&>(
+        "TestThreadUtils::ThreadUtilsObject::Test1rupi", rpt,
+        &ThreadUtilsObject::Test1rupi, upi);
+    // Passed as lref, so Run() must be called while local upi is still alive!
+    r1->Run();
+  }
+  EXPECT_EQ(count += 2, rpt->mCount);
+  EXPECT_EQ(-1, rpt->mA0);
+
+  // Verify copy/move assumptions.
+
+  Spy::ClearAll();
+  if (gDebug) {
+    printf("%d - Test: Store copy from lvalue, pass by value\n", __LINE__);
+  }
+  {  // Block around nsCOMPtr lifetime.
+    nsCOMPtr<nsIRunnable> r2;
+    {  // Block around Spy lifetime.
+      if (gDebug) {
+        printf("%d - Spy s(10)\n", __LINE__);
+      }
+      Spy s(10);
+      EXPECT_EQ(1, gConstructions);
+      EXPECT_EQ(1, gAlive);
+      if (gDebug) {
+        printf(
+            "%d - r2 = "
+            "NewRunnableMethod<StoreCopyPassByValue<Spy>>(&TestByValue, s)\n",
+            __LINE__);
+      }
+      r2 = NewRunnableMethod<StoreCopyPassByValue<Spy>>(
+          "TestThreadUtils::ThreadUtilsObject::TestByValue", rpt,
+          &ThreadUtilsObject::TestByValue, s);
+      EXPECT_EQ(2, gAlive);
+      EXPECT_LE(1, gCopyConstructions);  // At least 1 copy-construction.
+      Spy::ClearActions();
+      if (gDebug) {
+        printf("%d - End block with Spy s(10)\n", __LINE__);
+      }
+    }
+    EXPECT_EQ(1, gDestructions);
+    EXPECT_EQ(1, gAlive);
+    Spy::ClearActions();
+    if (gDebug) {
+      printf("%d - Run()\n", __LINE__);
+    }
+    r2->Run();
+    EXPECT_LE(1, gCopyConstructions);  // Another copy-construction in call.
+    EXPECT_EQ(10, rpt->mSpy.mID);
+    EXPECT_LE(1, gDestructions);
+    EXPECT_EQ(1, gAlive);
+    Spy::ClearActions();
+    if (gDebug) {
+      printf("%d - End block with r\n", __LINE__);
+    }
+  }
+  if (gDebug) {
+    printf("%d - After end block with r\n", __LINE__);
+  }
+  EXPECT_EQ(1, gDestructions);
+  EXPECT_EQ(0, gAlive);
+
+  Spy::ClearAll();
+  if (gDebug) {
+    printf("%d - Test: Store copy from prvalue, pass by value\n", __LINE__);
+  }
+  {
+    if (gDebug) {
+      printf(
+          "%d - r3 = "
+          "NewRunnableMethod<StoreCopyPassByValue<Spy>>(&TestByValue, "
+          "Spy(11))\n",
+          __LINE__);
+    }
+    nsCOMPtr<nsIRunnable> r3 = NewRunnableMethod<StoreCopyPassByValue<Spy>>(
+        "TestThreadUtils::ThreadUtilsObject::TestByValue", rpt,
+        &ThreadUtilsObject::TestByValue, Spy(11));
+    EXPECT_EQ(1, gAlive);
+    EXPECT_EQ(1, gConstructions);
+    EXPECT_LE(1, gMoveConstructions);
+    Spy::ClearActions();
+    if (gDebug) {
+      printf("%d - Run()\n", __LINE__);
+    }
+    r3->Run();
+    EXPECT_LE(1, gCopyConstructions);  // Another copy-construction in call.
+    EXPECT_EQ(11, rpt->mSpy.mID);
+    EXPECT_LE(1, gDestructions);
+    EXPECT_EQ(1, gAlive);
+    Spy::ClearActions();
+    if (gDebug) {
+      printf("%d - End block with r\n", __LINE__);
+    }
+  }
+  if (gDebug) {
+    printf("%d - After end block with r\n", __LINE__);
+  }
+  EXPECT_EQ(1, gDestructions);
+  EXPECT_EQ(0, gAlive);
+
+  Spy::ClearAll();
+  {  // Store copy from xvalue, pass by value.
+    nsCOMPtr<nsIRunnable> r4;
+    {
+      Spy s(12);
+      EXPECT_EQ(1, gConstructions);
+      EXPECT_EQ(1, gAlive);
+      Spy::ClearActions();
+      r4 = NewRunnableMethod<StoreCopyPassByValue<Spy>>(
+          "TestThreadUtils::ThreadUtilsObject::TestByValue", rpt,
+          &ThreadUtilsObject::TestByValue, std::move(s));
+      EXPECT_LE(1, gMoveConstructions);
+      EXPECT_EQ(1, gAlive);
+      EXPECT_EQ(1, gZombies);
+      Spy::ClearActions();
+    }
+    EXPECT_EQ(1, gDestructions);
+    EXPECT_EQ(1, gAlive);
+    EXPECT_EQ(0, gZombies);
+    Spy::ClearActions();
+    r4->Run();
+    EXPECT_LE(1, gCopyConstructions);  // Another copy-construction in call.
+    EXPECT_EQ(12, rpt->mSpy.mID);
+    EXPECT_LE(1, gDestructions);
+    EXPECT_EQ(1, gAlive);
+    Spy::ClearActions();
+  }
+  EXPECT_EQ(1, gDestructions);
+  EXPECT_EQ(0, gAlive);
+  // Won't test xvalues anymore, prvalues are enough to verify all rvalues.
+
+  Spy::ClearAll();
+  if (gDebug) {
+    printf("%d - Test: Store copy from lvalue, pass by const lvalue ref\n",
+           __LINE__);
+  }
+  {  // Block around nsCOMPtr lifetime.
+    nsCOMPtr<nsIRunnable> r5;
+    {  // Block around Spy lifetime.
+      if (gDebug) {
+        printf("%d - Spy s(20)\n", __LINE__);
+      }
+      Spy s(20);
+      EXPECT_EQ(1, gConstructions);
+      EXPECT_EQ(1, gAlive);
+      if (gDebug) {
+        printf(
+            "%d - r5 = "
+            "NewRunnableMethod<StoreCopyPassByConstLRef<Spy>>(&TestByConstLRef,"
+            " s)\n",
+            __LINE__);
+      }
+      r5 = NewRunnableMethod<StoreCopyPassByConstLRef<Spy>>(
+          "TestThreadUtils::ThreadUtilsObject::TestByConstLRef", rpt,
+          &ThreadUtilsObject::TestByConstLRef, s);
+      EXPECT_EQ(2, gAlive);
+      EXPECT_LE(1, gCopyConstructions);  // At least 1 copy-construction.
+      Spy::ClearActions();
+      if (gDebug) {
+        printf("%d - End block with Spy s(20)\n", __LINE__);
+      }
+    }
+    EXPECT_EQ(1, gDestructions);
+    EXPECT_EQ(1, gAlive);
+    Spy::ClearActions();
+    if (gDebug) {
+      printf("%d - Run()\n", __LINE__);
+    }
+    r5->Run();
+    EXPECT_EQ(0, gCopyConstructions);  // No copies in call.
+    EXPECT_EQ(20, rpt->mSpy.mID);
+    EXPECT_EQ(0, gDestructions);
+    EXPECT_EQ(1, gAlive);
+    Spy::ClearActions();
+    if (gDebug) {
+      printf("%d - End block with r\n", __LINE__);
+    }
+  }
+  if (gDebug) {
+    printf("%d - After end block with r\n", __LINE__);
+  }
+  EXPECT_EQ(1, gDestructions);
+  EXPECT_EQ(0, gAlive);
+
+  Spy::ClearAll();
+  if (gDebug) {
+    printf("%d - Test: Store copy from prvalue, pass by const lvalue ref\n",
+           __LINE__);
+  }
+  {
+    if (gDebug) {
+      printf(
+          "%d - r6 = "
+          "NewRunnableMethod<StoreCopyPassByConstLRef<Spy>>(&TestByConstLRef, "
+          "Spy(21))\n",
+          __LINE__);
+    }
+    nsCOMPtr<nsIRunnable> r6 = NewRunnableMethod<StoreCopyPassByConstLRef<Spy>>(
+        "TestThreadUtils::ThreadUtilsObject::TestByConstLRef", rpt,
+        &ThreadUtilsObject::TestByConstLRef, Spy(21));
+    EXPECT_EQ(1, gAlive);
+    EXPECT_EQ(1, gConstructions);
+    EXPECT_LE(1, gMoveConstructions);
+    Spy::ClearActions();
+    if (gDebug) {
+      printf("%d - Run()\n", __LINE__);
+    }
+    r6->Run();
+    EXPECT_EQ(0, gCopyConstructions);  // No copies in call.
+    EXPECT_EQ(21, rpt->mSpy.mID);
+    EXPECT_EQ(0, gDestructions);
+    EXPECT_EQ(1, gAlive);
+    Spy::ClearActions();
+    if (gDebug) {
+      printf("%d - End block with r\n", __LINE__);
+    }
+  }
+  if (gDebug) {
+    printf("%d - After end block with r\n", __LINE__);
+  }
+  EXPECT_EQ(1, gDestructions);
+  EXPECT_EQ(0, gAlive);
+
+  Spy::ClearAll();
+  if (gDebug) {
+    printf("%d - Test: Store copy from lvalue, pass by rvalue ref\n", __LINE__);
+  }
+  {  // Block around nsCOMPtr lifetime.
+    nsCOMPtr<nsIRunnable> r7;
+    {  // Block around Spy lifetime.
+      if (gDebug) {
+        printf("%d - Spy s(30)\n", __LINE__);
+      }
+      Spy s(30);
+      EXPECT_EQ(1, gConstructions);
+      EXPECT_EQ(1, gAlive);
+      if (gDebug) {
+        printf(
+            "%d - r7 = "
+            "NewRunnableMethod<StoreCopyPassByRRef<Spy>>(&TestByRRef, s)\n",
+            __LINE__);
+      }
+      r7 = NewRunnableMethod<StoreCopyPassByRRef<Spy>>(
+          "TestThreadUtils::ThreadUtilsObject::TestByRRef", rpt,
+          &ThreadUtilsObject::TestByRRef, s);
+      EXPECT_EQ(2, gAlive);
+      EXPECT_LE(1, gCopyConstructions);  // At least 1 copy-construction.
+      Spy::ClearActions();
+      if (gDebug) {
+        printf("%d - End block with Spy s(30)\n", __LINE__);
+      }
+    }
+    EXPECT_EQ(1, gDestructions);
+    EXPECT_EQ(1, gAlive);
+    Spy::ClearActions();
+    if (gDebug) {
+      printf("%d - Run()\n", __LINE__);
+    }
+    r7->Run();
+    EXPECT_LE(1, gMoves);  // Move in call.
+    EXPECT_EQ(30, rpt->mSpy.mID);
+    EXPECT_EQ(0, gDestructions);
+    EXPECT_EQ(0, gAlive);    // Spy inside Test is not counted.
+    EXPECT_EQ(1, gZombies);  // Our local spy should now be a zombie.
+    Spy::ClearActions();
+    if (gDebug) {
+      printf("%d - End block with r\n", __LINE__);
+    }
+  }
+  if (gDebug) {
+    printf("%d - After end block with r\n", __LINE__);
+  }
+  EXPECT_EQ(1, gDestructions);
+  EXPECT_EQ(0, gAlive);
+
+  Spy::ClearAll();
+  if (gDebug) {
+    printf("%d - Test: Store copy from prvalue, pass by rvalue ref\n",
+           __LINE__);
+  }
+  {
+    if (gDebug) {
+      printf(
+          "%d - r8 = NewRunnableMethod<StoreCopyPassByRRef<Spy>>(&TestByRRef, "
+          "Spy(31))\n",
+          __LINE__);
+    }
+    nsCOMPtr<nsIRunnable> r8 = NewRunnableMethod<StoreCopyPassByRRef<Spy>>(
+        "TestThreadUtils::ThreadUtilsObject::TestByRRef", rpt,
+        &ThreadUtilsObject::TestByRRef, Spy(31));
+    EXPECT_EQ(1, gAlive);
+    EXPECT_EQ(1, gConstructions);
+    EXPECT_LE(1, gMoveConstructions);
+    Spy::ClearActions();
+    if (gDebug) {
+      printf("%d - Run()\n", __LINE__);
+    }
+    r8->Run();
+    EXPECT_LE(1, gMoves);  // Move in call.
+    EXPECT_EQ(31, rpt->mSpy.mID);
+    EXPECT_EQ(0, gDestructions);
+    EXPECT_EQ(0, gAlive);    // Spy inside Test is not counted.
+    EXPECT_EQ(1, gZombies);  // Our local spy should now be a zombie.
+    Spy::ClearActions();
+    if (gDebug) {
+      printf("%d - End block with r\n", __LINE__);
+    }
+  }
+  if (gDebug) {
+    printf("%d - After end block with r\n", __LINE__);
+  }
+  EXPECT_EQ(1, gDestructions);
+  EXPECT_EQ(0, gAlive);
+
+  Spy::ClearAll();
+  if (gDebug) {
+    printf("%d - Test: Store lvalue ref, pass lvalue ref\n", __LINE__);
+  }
+  {
+    if (gDebug) {
+      printf("%d - Spy s(40)\n", __LINE__);
+    }
+    Spy s(40);
+    EXPECT_EQ(1, gConstructions);
+    EXPECT_EQ(1, gAlive);
+    Spy::ClearActions();
+    if (gDebug) {
+      printf("%d - r9 = NewRunnableMethod<Spy&>(&TestByLRef, s)\n", __LINE__);
+    }
+    nsCOMPtr<nsIRunnable> r9 = NewRunnableMethod<Spy&>(
+        "TestThreadUtils::ThreadUtilsObject::TestByLRef", rpt,
+        &ThreadUtilsObject::TestByLRef, s);
+    EXPECT_EQ(0, gAllConstructions);
+    EXPECT_EQ(0, gDestructions);
+    EXPECT_EQ(1, gAlive);
+    Spy::ClearActions();
+    if (gDebug) {
+      printf("%d - Run()\n", __LINE__);
+    }
+    r9->Run();
+    EXPECT_LE(1, gAssignments);  // Assignment from reference in call.
+    EXPECT_EQ(40, rpt->mSpy.mID);
+    EXPECT_EQ(&s, rpt->mSpyPtr);
+    EXPECT_EQ(0, gDestructions);
+    EXPECT_EQ(1, gAlive);  // Spy inside Test is not counted.
+    Spy::ClearActions();
+    if (gDebug) {
+      printf("%d - End block with r\n", __LINE__);
+    }
+  }
+  if (gDebug) {
+    printf("%d - After end block with r\n", __LINE__);
+  }
+  EXPECT_EQ(1, gDestructions);
+  EXPECT_EQ(0, gAlive);
+
+  Spy::ClearAll();
+  if (gDebug) {
+    printf("%d - Test: Store nsRefPtr, pass by pointer\n", __LINE__);
+  }
+  {  // Block around nsCOMPtr lifetime.
+    nsCOMPtr<nsIRunnable> r10;
+    SpyWithISupports* ptr = 0;
+    {  // Block around RefPtr<Spy> lifetime.
+      if (gDebug) {
+        printf("%d - RefPtr<SpyWithISupports> s(new SpyWithISupports(45))\n",
+               __LINE__);
+      }
+      RefPtr<SpyWithISupports> s(new SpyWithISupports(45));
+      ptr = s.get();
+      EXPECT_EQ(1, gConstructions);
+      EXPECT_EQ(1, gAlive);
+      if (gDebug) {
+        printf(
+            "%d - r10 = "
+            "NewRunnableMethod<StoreRefPtrPassByPtr<Spy>>(&TestByRRef, "
+            "s.get())\n",
+            __LINE__);
+      }
+      r10 = NewRunnableMethod<StoreRefPtrPassByPtr<SpyWithISupports>>(
+          "TestThreadUtils::ThreadUtilsObject::TestByPointer", rpt,
+          &ThreadUtilsObject::TestByPointer, s.get());
+      EXPECT_LE(0, gAllConstructions);
+      EXPECT_EQ(1, gAlive);
+      Spy::ClearActions();
+      if (gDebug) {
+        printf("%d - End block with RefPtr<Spy> s\n", __LINE__);
+      }
+    }
+    EXPECT_EQ(0, gDestructions);
+    EXPECT_EQ(1, gAlive);
+    Spy::ClearActions();
+    if (gDebug) {
+      printf("%d - Run()\n", __LINE__);
+    }
+    r10->Run();
+    EXPECT_LE(1, gAssignments);  // Assignment from pointee in call.
+    EXPECT_EQ(45, rpt->mSpy.mID);
+    EXPECT_EQ(ptr, rpt->mSpyPtr);
+    EXPECT_EQ(0, gDestructions);
+    EXPECT_EQ(1, gAlive);  // Spy inside Test is not counted.
+    Spy::ClearActions();
+    if (gDebug) {
+      printf("%d - End block with r\n", __LINE__);
+    }
+  }
+  if (gDebug) {
+    printf("%d - After end block with r\n", __LINE__);
+  }
+  EXPECT_EQ(1, gDestructions);
+  EXPECT_EQ(0, gAlive);
+
+  Spy::ClearAll();
+  if (gDebug) {
+    printf("%d - Test: Store pointer to lvalue, pass by pointer\n", __LINE__);
+  }
+  {
+    if (gDebug) {
+      printf("%d - Spy s(55)\n", __LINE__);
+    }
+    Spy s(55);
+    EXPECT_EQ(1, gConstructions);
+    EXPECT_EQ(1, gAlive);
+    Spy::ClearActions();
+    if (gDebug) {
+      printf("%d - r11 = NewRunnableMethod<Spy*>(&TestByPointer, s)\n",
+             __LINE__);
+    }
+    nsCOMPtr<nsIRunnable> r11 = NewRunnableMethod<Spy*>(
+        "TestThreadUtils::ThreadUtilsObject::TestByPointer", rpt,
+        &ThreadUtilsObject::TestByPointer, &s);
+    EXPECT_EQ(0, gAllConstructions);
+    EXPECT_EQ(0, gDestructions);
+    EXPECT_EQ(1, gAlive);
+    Spy::ClearActions();
+    if (gDebug) {
+      printf("%d - Run()\n", __LINE__);
+    }
+    r11->Run();
+    EXPECT_LE(1, gAssignments);  // Assignment from pointee in call.
+    EXPECT_EQ(55, rpt->mSpy.mID);
+    EXPECT_EQ(&s, rpt->mSpyPtr);
+    EXPECT_EQ(0, gDestructions);
+    EXPECT_EQ(1, gAlive);  // Spy inside Test is not counted.
+    Spy::ClearActions();
+    if (gDebug) {
+      printf("%d - End block with r\n", __LINE__);
+    }
+  }
+  if (gDebug) {
+    printf("%d - After end block with r\n", __LINE__);
+  }
+  EXPECT_EQ(1, gDestructions);
+  EXPECT_EQ(0, gAlive);
+
+  Spy::ClearAll();
+  if (gDebug) {
+    printf("%d - Test: Store pointer to const lvalue, pass by pointer\n",
+           __LINE__);
+  }
+  {
+    if (gDebug) {
+      printf("%d - Spy s(60)\n", __LINE__);
+    }
+    Spy s(60);
+    EXPECT_EQ(1, gConstructions);
+    EXPECT_EQ(1, gAlive);
+    Spy::ClearActions();
+    if (gDebug) {
+      printf("%d - r12 = NewRunnableMethod<Spy*>(&TestByPointer, s)\n",
+             __LINE__);
+    }
+    nsCOMPtr<nsIRunnable> r12 = NewRunnableMethod<const Spy*>(
+        "TestThreadUtils::ThreadUtilsObject::TestByPointerToConst", rpt,
+        &ThreadUtilsObject::TestByPointerToConst, &s);
+    EXPECT_EQ(0, gAllConstructions);
+    EXPECT_EQ(0, gDestructions);
+    EXPECT_EQ(1, gAlive);
+    Spy::ClearActions();
+    if (gDebug) {
+      printf("%d - Run()\n", __LINE__);
+    }
+    r12->Run();
+    EXPECT_LE(1, gAssignments);  // Assignment from pointee in call.
+    EXPECT_EQ(60, rpt->mSpy.mID);
+    EXPECT_EQ(&s, rpt->mSpyPtr);
+    EXPECT_EQ(0, gDestructions);
+    EXPECT_EQ(1, gAlive);  // Spy inside Test is not counted.
+    Spy::ClearActions();
+    if (gDebug) {
+      printf("%d - End block with r\n", __LINE__);
+    }
+  }
+  if (gDebug) {
+    printf("%d - After end block with r\n", __LINE__);
+  }
+  EXPECT_EQ(1, gDestructions);
+  EXPECT_EQ(0, gAlive);
+}